# php_manual

id: PASSWORD_DEFAULT
type: constant
doc:
<comment>Description:</comment>
  The default algorithm to use for hashing if no algorithm is provided. This may change in newer PHP
  releases when newer, stronger hashing algorithms are supported.
  
  It is worth noting that over time this constant can (and likely will) change. Therefore you should
  be aware that the length of the resulting hash can change. Therefore, if you use <info>PASSWORD_DEFAULT</info>
  you should store the resulting hash in a way that can store more than 60 characters (255 is the
  recommended width).
  
  Values for this constant:
  
  PHP 5.5.0 - <info>PASSWORD_BCRYPT</info>


id: PCRE_VERSION
type: constant
doc:
<comment>Description:</comment>
  PCRE version and release date (e.g. "<return>7.0 18-Dec-2006</return>").
  
  5.2.4


id: PDO::ATTR_AUTOCOMMIT
type: constant
doc:
<comment>Description:</comment>
  If this value is <info>false</info>, PDO attempts to disable autocommit so that the connection begins a
  transaction.


id: PDO::ATTR_CASE
type: constant
doc:
<comment>Description:</comment>
  Force column names to a specific case specified by the <return>PDO::CASE_*</return> constants.


id: PDO::ATTR_CLIENT_VERSION
type: constant
doc:
<comment>Description:</comment>
  This is a read only attribute; it will return information about the version of the client
  libraries that the PDO driver is using.


id: PDO::ATTR_CURSOR
type: constant
doc:
<comment>Description:</comment>
  Selects the cursor type.  PDO currently supports either <info>PDO::CURSOR_FWDONLY</info> and
  <info>PDO::CURSOR_SCROLL</info>. Stick with <info>PDO::CURSOR_FWDONLY</info> unless you know that you need a scrollable
  cursor.


id: PDO::ATTR_CURSOR_NAME
type: constant
doc:
<comment>Description:</comment>
  Get or set the name to use for a cursor.  Most useful when using scrollable cursors and positioned
  updates.


id: PDO::ATTR_DEFAULT_STR_PARAM
type: constant
doc:
<comment>Description:</comment>
  Sets the default string parameter type, this can be one of <info>PDO::PARAM_STR_NATL</info>  and
  <info>PDO::PARAM_STR_CHAR</info>.
  
  Available since PHP 7.2.0.


id: PDO::ATTR_DRIVER_NAME
type: constant
doc:
<comment>Description:</comment>
  Returns the name of the driver.
  
  using <info>PDO::ATTR_DRIVER_NAME</info>getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql') { echo "Running on
  mysql; doing something mysql specific here\n";
  }
  ?>
  ]]>


id: PDO::ATTR_ERRMODE
type: constant
doc:
<comment>Description:</comment>
  See the Errors and error handling section for more information about this attribute.


id: PDO::ATTR_FETCH_CATALOG_NAMES
type: constant
doc:
<comment>Description:</comment>
  Prepend the containing catalog name to each column name returned in the result set. The catalog
  name and column name are separated by a decimal (.) character.  Support of this attribute is at
  the driver level; it may not be supported by your driver.


id: PDO::ATTR_FETCH_TABLE_NAMES
type: constant
doc:
<comment>Description:</comment>
  Prepend the containing table name to each column name returned in the result set. The table name
  and column name are separated by a decimal (.) character. Support of this attribute is at the
  driver level; it may not be supported by your driver.


id: PDO::ATTR_PERSISTENT
type: constant
doc:
<comment>Description:</comment>
  Request a persistent connection, rather than creating a new connection. See Connections and
  Connection management for more information on this attribute.


id: PDO::ATTR_PREFETCH
type: constant
doc:
<comment>Description:</comment>
  Setting the prefetch size allows you to balance speed against memory usage for your application.
  Not all database/driver combinations support setting of the prefetch size.  A larger prefetch size
  results in increased performance at the cost of higher memory usage.


id: PDO::ATTR_SERVER_INFO
type: constant
doc:
<comment>Description:</comment>
  This is a read only attribute; it will return some meta information about the database server to
  which PDO is connected.


id: PDO::ATTR_SERVER_VERSION
type: constant
doc:
<comment>Description:</comment>
  This is a read only attribute; it will return information about the version of the database server
  to which PDO is connected.


id: PDO::ATTR_TIMEOUT
type: constant
doc:
<comment>Description:</comment>
  Sets the timeout value in seconds for communications with the database.


id: PDO::CURSOR_FWDONLY
type: constant
doc:
<comment>Description:</comment>
  Create a <class>PDOStatement</class> object with a forward-only cursor.  This is the default cursor choice, as it
  is the fastest and most common data access pattern in PHP.


id: PDO::CURSOR_SCROLL
type: constant
doc:
<comment>Description:</comment>
  Create a <class>PDOStatement</class> object with a scrollable cursor. Pass the <return>PDO::FETCH_ORI_*</return> constants to
  control the rows fetched from the result set.


id: PDO::ERRMODE_EXCEPTION
type: constant
doc:
<comment>Description:</comment>
  Throw a <class>PDOException</class> if an error occurs. See Errors and error handling for more information about
  this attribute.


id: PDO::ERRMODE_SILENT
type: constant
doc:
<comment>Description:</comment>
  Do not raise an error or exception if an error occurs. The developer is expected to explicitly
  check for errors.  This is the default mode. See Errors and error handling for more information
  about this attribute.


id: PDO::ERRMODE_WARNING
type: constant
doc:
<comment>Description:</comment>
  Issue a PHP <info>E_WARNING</info> message if an error occurs. See Errors and error handling for more
  information about this attribute.


id: PDO::ERR_NONE
type: constant
doc:
<comment>Description:</comment>
  Corresponds to SQLSTATE '00000', meaning that the SQL statement was successfully issued with no
  errors or warnings.  This constant is for your convenience when checking PDO::errorCode or
  PDOStatement::errorCode to determine if an error occurred.  You will usually know if this is the
  case by examining the return code from the method that raised the error condition anyway.


id: PDO::FETCH_ASSOC
type: constant
doc:
<comment>Description:</comment>
  Specifies that the fetch method shall return each row as an array indexed by column name as
  returned in the corresponding result set. If the result set contains multiple columns with the
  same name, <info>PDO::FETCH_ASSOC</info> returns only a single value per column name.


id: PDO::FETCH_BOTH
type: constant
doc:
<comment>Description:</comment>
  Specifies that the fetch method shall return each row as an array indexed by both column name and
  number as returned in the corresponding result set, starting at column 0.


id: PDO::FETCH_BOUND
type: constant
doc:
<comment>Description:</comment>
  Specifies that the fetch method shall return TRUE and assign the values of the columns in the
  result set to the PHP variables to which they were bound with the PDOStatement::bindParam or
  PDOStatement::bindColumn methods.


id: PDO::FETCH_CLASS
type: constant
doc:
<comment>Description:</comment>
  Specifies that the fetch method shall return a new instance of the requested class, mapping the
  columns to named properties in the class.
  
  The magic __set method is called if the property doesn't exist in the requested class


id: PDO::FETCH_COLUMN
type: constant
doc:
<comment>Description:</comment>
  Specifies that the fetch method shall return only a single requested column from the next row in
  the result set.


id: PDO::FETCH_DEFAULT
type: constant
doc:
<comment>Description:</comment>
  Specifies that the default fetch mode shall be used. Available as of PHP 8.0.7.


id: PDO::FETCH_FUNC
type: constant
doc:
<comment>Description:</comment>
  Allows completely customize the way data is treated on the fly (only  valid inside
  PDOStatement::fetchAll).


id: PDO::FETCH_GROUP
type: constant
doc:
<comment>Description:</comment>
  Group return by values. Usually combined with <info>PDO::FETCH_COLUMN</info> or  <info>PDO::FETCH_KEY_PAIR</info>.


id: PDO::FETCH_INTO
type: constant
doc:
<comment>Description:</comment>
  Specifies that the fetch method shall update an existing instance of the requested class, mapping
  the columns to named properties in the class.


id: PDO::FETCH_KEY_PAIR
type: constant
doc:
<comment>Description:</comment>
  Fetch a two-column result into an array where the first column is a key and the second column is
  the value.


id: PDO::FETCH_LAZY
type: constant
doc:
<comment>Description:</comment>
  Specifies that the fetch method shall return each row as an object with variable names that
  correspond to the column names returned in the result set. <info>PDO::FETCH_LAZY</info> creates the object
  variable names as they are accessed. Not valid inside PDOStatement::fetchAll.


id: PDO::FETCH_NAMED
type: constant
doc:
<comment>Description:</comment>
  Specifies that the fetch method shall return each row as an array indexed by column name as
  returned in the corresponding result set. If the result set contains multiple columns with the
  same name, <info>PDO::FETCH_NAMED</info> returns an array of values per column name.


id: PDO::FETCH_NUM
type: constant
doc:
<comment>Description:</comment>
  Specifies that the fetch method shall return each row as an array indexed by column number as
  returned in the corresponding result set, starting at column 0.


id: PDO::FETCH_OBJ
type: constant
doc:
<comment>Description:</comment>
  Specifies that the fetch method shall return each row as an object with property names that
  correspond to the column names returned in the result set.


id: PDO::FETCH_ORI_ABS
type: constant
doc:
<comment>Description:</comment>
  Fetch the requested row by row number from the result set. Valid only for scrollable cursors.


id: PDO::FETCH_ORI_FIRST
type: constant
doc:
<comment>Description:</comment>
  Fetch the first row in the result set. Valid only for scrollable cursors.


id: PDO::FETCH_ORI_LAST
type: constant
doc:
<comment>Description:</comment>
  Fetch the last row in the result set. Valid only for scrollable cursors.


id: PDO::FETCH_ORI_NEXT
type: constant
doc:
<comment>Description:</comment>
  Fetch the next row in the result set. Valid only for scrollable cursors.


id: PDO::FETCH_ORI_PRIOR
type: constant
doc:
<comment>Description:</comment>
  Fetch the previous row in the result set. Valid only for scrollable cursors.


id: PDO::FETCH_ORI_REL
type: constant
doc:
<comment>Description:</comment>
  Fetch the requested row by relative position from the current position of the cursor in the result
  set. Valid only for scrollable cursors.


id: PDO::FETCH_SERIALIZE
type: constant
doc:
<comment>Description:</comment>
  As <info>PDO::FETCH_INTO</info> but object is provided as a serialized string. The class constructor is never
  called if this flag is set. Deprecated as of PHP 8.1.0.


id: PDO::MYSQL_ATTR_FOUND_ROWS
type: constant
doc:
<comment>Description:</comment>
  Return the number of found (matched) rows, not the  number of changed rows.


id: PDO::MYSQL_ATTR_IGNORE_SPACE
type: constant
doc:
<comment>Description:</comment>
  Permit spaces after function names. Makes all functions  names reserved words.


id: PDO::MYSQL_ATTR_INIT_COMMAND
type: constant
doc:
<comment>Description:</comment>
  Command to execute when connecting to the MySQL server. Will automatically be re-executed when
  reconnecting.
  
  Note, this constant can only be used in the <strong>$driver_options</strong>  array when constructing a new
  database handle.


id: PDO::MYSQL_ATTR_LOCAL_INFILE
type: constant
doc:
<comment>Description:</comment>
  Enable <return>LOAD LOCAL INFILE</return>.
  
  Note, this constant can only be used in the <strong>$driver_options</strong>  array when constructing a new
  database handle.


id: PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY
type: constant
doc:
<comment>Description:</comment>
  Allows restricting LOCAL DATA loading to files located in this designated  directory. Available as
  of PHP 8.1.0.
  
  Note, this constant can only be used in the <strong>$driver_options</strong>  array when constructing a new
  database handle.


id: PDO::MYSQL_ATTR_MAX_BUFFER_SIZE
type: constant
doc:
<comment>Description:</comment>
  Maximum buffer size. Defaults to 1 MiB. This constant is not supported when  compiled against
  mysqlnd.


id: PDO::MYSQL_ATTR_MULTI_STATEMENTS
type: constant
doc:
<comment>Description:</comment>
  Disables multi query execution in both <strong>PDO::prepare()</strong> and <strong>PDO::query()</strong> when set to <info>false</info>.
  
  Note, this constant can only be used in the <strong>$driver_options</strong>  array when constructing a new
  database handle.


id: PDO::MYSQL_ATTR_READ_DEFAULT_FILE
type: constant
doc:
<comment>Description:</comment>
  Read options from the named option file instead of from my.cnf. This option is not available if
  mysqlnd is used, because mysqlnd does not read the mysql  configuration files.


id: PDO::MYSQL_ATTR_READ_DEFAULT_GROUP
type: constant
doc:
<comment>Description:</comment>
  Read options from the named group from my.cnf or the file specified with <info>MYSQL_READ_DEFAULT_FILE</info>.
  This option  is not available if mysqlnd is used, because mysqlnd does not read the mysql
  configuration files.


id: PDO::MYSQL_ATTR_SSL_CAPATH
type: constant
doc:
<comment>Description:</comment>
  The file path to the directory that contains the trusted SSL CA certificates, which are stored in
  PEM format.


id: PDO::MYSQL_ATTR_SSL_CIPHER
type: constant
doc:
<comment>Description:</comment>
  A list of one or more permissible ciphers to use for SSL encryption, in a format understood by
  OpenSSL. For example: <return>DHE-RSA-AES256-SHA:AES128-SHA</return>


id: PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT
type: constant
doc:
<comment>Description:</comment>
  Provides a way to disable verification of the server SSL certificate.
  
  This exists as of PHP  7.0.18 and PHP 7.1.4.


id: PDO::MYSQL_ATTR_USE_BUFFERED_QUERY
type: constant
doc:
<comment>Description:</comment>
  By default all statements are executed in buffered mode. If this attribute is set to <info>false</info> on a
  <class>PDO</class> object, the MySQL driver will use the unbuffered mode.
  
  Setting MySQL unbuffered modesetAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
  
  $unbufferedResult = $pdo->query("SELECT Name FROM City");
  foreach ($unbufferedResult as $row) { echo $row['Name'] . PHP_EOL;
  }
  ?>
  ]]>


id: PDO::OCI_ATTR_ACTION
type: constant
doc:
<comment>Description:</comment>
  Provides a way to specify the action on the database session.
  
  This exists as of PHP  7.2.16 and 7.3.3


id: PDO::OCI_ATTR_CLIENT_IDENTIFIER
type: constant
doc:
<comment>Description:</comment>
  Provides a way to specify the client identifier on the database session.
  
  This exists as of PHP  7.2.16 and 7.3.3


id: PDO::OCI_ATTR_CLIENT_INFO
type: constant
doc:
<comment>Description:</comment>
  Provides a way to specify the client info on the database session.
  
  This exists as of PHP  7.2.16 and 7.3.3


id: PDO::OCI_ATTR_MODULE
type: constant
doc:
<comment>Description:</comment>
  Provides a way to specify the module on the database session.
  
  This exists as of PHP  7.2.16 and 7.3.3


id: PDO::ODBC_ATTR_ASSUME_UTF8
type: constant
doc:
<comment>Description:</comment>
  Windows only. If <info>true</info>, UTF-16 encoded character data (<return>CHAR</return>, <return>VARCHAR</return> and <return>LONGVARCHAR</return>) is converted
  to UTF-8 when reading from or writing data to the database. If <info>false</info> (the default), character
  encoding conversion may be done by the driver.


id: PDO::ODBC_ATTR_USE_CURSOR_LIBRARY
type: constant
doc:
<comment>Description:</comment>
  This option controls whether the ODBC cursor library is used. The ODBC cursor library supports
  some advanced ODBC features (e.g. block scrollable cursors), which may not be implemented by the
  driver. The following values are supported: <info>PDO::ODBC_SQL_USE_IF_NEEDED</info> (the default): use the
  ODBC cursor library when needed. <info>PDO::ODBC_SQL_USE_DRIVER</info>: never use the ODBC cursor library.
  <info>PDO::ODBC_SQL_USE_ODBC</info>: always use the ODBC cursor library.
  
  <info>PDO::ODBC_SQL_USE_IF_NEEDED</info> (the default): use the ODBC cursor library when needed.
  
  <info>PDO::ODBC_SQL_USE_DRIVER</info>: never use the ODBC cursor library.
  
  <info>PDO::ODBC_SQL_USE_ODBC</info>: always use the ODBC cursor library.


id: PDO::PARAM_EVT_FETCH_POST
type: constant
doc:
<comment>Description:</comment>
  Event triggered subsequent to fetching a result from a resultset.


id: PDO::PARAM_EVT_NORMALIZE
type: constant
doc:
<comment>Description:</comment>
  Event triggered during bound parameter registration allowing the driver to normalize the parameter
  name.


id: PDO::PARAM_INPUT_OUTPUT
type: constant
doc:
<comment>Description:</comment>
  Specifies that the parameter is an INOUT parameter for a stored procedure. You must bitwise-OR
  this value with an explicit PDO::PARAM_* data type.


id: PDO::PARAM_STMT
type: constant
doc:
<comment>Description:</comment>
  Represents a recordset type.  Not currently supported by any drivers.


id: PDO::PARAM_STR_CHAR
type: constant
doc:
<comment>Description:</comment>
  Flag to denote a string uses the regular character set.
  
  Available since PHP 7.2.0


id: PDO::PARAM_STR_NATL
type: constant
doc:
<comment>Description:</comment>
  Flag to denote a string uses the national character set.
  
  Available since PHP 7.2.0


id: PDO::PGSQL_ATTR_DISABLE_PREPARES
type: constant
doc:
<comment>Description:</comment>
  Send the query and the parameters to the server together in a single call, avoiding the need to
  create a named prepared statement separately. If the query is only going to be executed once this
  can reduce latency by avoiding an unnecessary server round-trip.


id: PDO::SQLITE_DETERMINISTIC
type: constant
doc:
<comment>Description:</comment>
  Specifies that a function created with PDO::sqliteCreateFunction is deterministic, i.e. it always
  returns the same result given the same inputs within a single SQL statement. (Available as of PHP
  7.1.4.)


id: PDO::SQLSRV_ATTR_DIRECT_QUERY
type: constant
doc:
<comment>Description:</comment>
  Indicates that a query should be executed directly, without being prepared.  This constant can be
  passed to PDO::setAttribute, and PDO::prepare. For more  information, see  Direct and Prepared
  Statement Execution.


id: PDO::SQLSRV_ATTR_QUERY_TIMEOUT
type: constant
doc:
<comment>Description:</comment>
  A non-negative integer representing the timeout period, in seconds. Zero (0)  is the default and
  means no timeout. This constant can be passed to  PDOStatement::setAttribute, PDO::setAttribute,
  and PDO::prepare.


id: PDO::SQLSRV_ENCODING_BINARY
type: constant
doc:
<comment>Description:</comment>
  Specifies that data is sent/retrieved as a raw byte stream to/from the server  without performing
  encoding or translation. This constant can be passed to  PDOStatement::setAttribute, PDO::prepare,
  PDOStatement::bindColumn, and  PDOStatement::bindParam.


id: PDO::SQLSRV_ENCODING_DEFAULT
type: constant
doc:
<comment>Description:</comment>
  Specifies that data is sent/retrieved to/from the server according to  PDO::SQLSRV_ENCODING_SYSTEM
  if specified during connection. The connection's  encoding is used if specified in a prepare
  statement. This constant can be  passed to PDOStatement::setAttribute, PDO::setAttribute,
  PDO::prepare,  PDOStatement::bindColumn, and PDOStatement::bindParam.


id: PDO::SQLSRV_ENCODING_SYSTEM
type: constant
doc:
<comment>Description:</comment>
  Specifies that data is sent/retrieved to/from the server as 8-bit characters  as specified in the
  code page of the Windows locale that is set on the system.  Any multi-byte characters or
  characters that do not map into this code page  are substituted with a single byte question mark
  (?) character. This constant  can be passed to PDOStatement::setAttribute, PDO::setAttribute,
  PDO::prepare,  PDOStatement::bindColumn, and PDOStatement::bindParam.


id: PDO::SQLSRV_ENCODING_UTF8
type: constant
doc:
<comment>Description:</comment>
  Specifies that data is sent/retrieved to/from the server in UTF-8 encoding.  This is the default
  encoding. This constant can be passed to  PDOStatement::setAttribute, PDO::setAttribute,
  PDO::prepare,  PDOStatement::bindColumn, and PDOStatement::bindParam.


id: PDO::SQLSRV_TXN_READ_COMMITTED
type: constant
doc:
<comment>Description:</comment>
  This constant is an acceptable value for the SQLSRV DSN key TransactionIsolation.  This constant
  sets the transaction isolation level for the connection to  Read Committed.


id: PDO::SQLSRV_TXN_READ_UNCOMMITTED
type: constant
doc:
<comment>Description:</comment>
  This constant is an acceptable value for the SQLSRV DSN key TransactionIsolation.  This constant
  sets the transaction isolation level for the connection to  Read Uncommitted.


id: PDO::SQLSRV_TXN_REPEATABLE_READ
type: constant
doc:
<comment>Description:</comment>
  This constant is an acceptable value for the SQLSRV DSN key TransactionIsolation.  This constant
  sets the transaction isolation level for the connection to  Repeateable Read.


id: PDO::SQLSRV_TXN_SERIALIZABLE
type: constant
doc:
<comment>Description:</comment>
  This constant is an acceptable value for the SQLSRV DSN key TransactionIsolation.  This constant
  sets the transaction isolation level for the connection to  Serializable.


id: PDO::SQLSRV_TXN_SNAPSHOT
type: constant
doc:
<comment>Description:</comment>
  This constant is an acceptable value for the SQLSRV DSN key TransactionIsolation.  This constant
  sets the transaction isolation level for the connection to Snapshot.


id: PDO::__construct
type: function
doc:
<comment>Description:</comment>
  Creates a PDO instance representing a connection to a database
    
  
  Creates a PDO instance to represent a connection to the requested database.

<comment>Param:</comment>
  <info>string</info>       <strong>$dsn</strong>       The Data Source Name, or DSN, contains the information required to connect
                          to the database.
                          
                          In general, a DSN consists of the PDO driver name, followed by a colon,
                          followed by the PDO driver-specific connection syntax. Further information
                          is available from the PDO driver-specific documentation.
                          
                          The <strong>$dsn</strong> parameter supports three different methods of specifying the
                          arguments required to create a database connection:
                          
                          Driver invocation<strong>$dsn</strong> contains the full DSN. URI invocation<strong>$dsn</strong> consists
                          of uri: followed by a URI that defines the location of a file containing
                          the DSN string. The URI can specify a local file or a remote URL.
                          uri:file:///path/to/dsnfileAliasing<strong>$dsn</strong> consists of a name  <strong>$name</strong> that
                          maps to  pdo.dsn.<strong>$name</strong> in php.ini defining the DSN string.  The alias must
                          be defined in php.ini, and not .htaccess or httpd.conf
                          
                          <strong>$dsn</strong> contains the full DSN.
                          
                          <strong>$dsn</strong> consists of uri: followed by a URI that defines the location of a
                          file containing the DSN string. The URI can specify a local file or a
                          remote URL.
                          
                          uri:file:///path/to/dsnfile
                          
                          <strong>$dsn</strong> consists of a name  <strong>$name</strong> that maps to  pdo.dsn.<strong>$name</strong> in php.ini
                          defining the DSN string.
                          
                          The alias must be defined in php.ini, and not .htaccess or httpd.conf
  <info>string</info>       <strong>$dsn</strong>       <strong>$dsn</strong> contains the full DSN.
  <info>string</info>       <strong>$dsn</strong>       <strong>$dsn</strong> consists of uri: followed by a URI that defines the location of a
                          file containing the DSN string. The URI can specify a local file or a
                          remote URL.
                          
                          uri:file:///path/to/dsnfile
  <info>string</info>       <strong>$dsn</strong>       <strong>$dsn</strong> consists of a name  <strong>$name</strong> that maps to  pdo.dsn.<strong>$name</strong> in php.ini
                          defining the DSN string.
                          
                          The alias must be defined in php.ini, and not .htaccess or httpd.conf
  <info>string|null</info>  <strong>$username</strong>  The user name for the DSN string. This parameter is optional for some PDO
                          drivers.
  <info>string|null</info>  <strong>$password</strong>  The password for the DSN string. This parameter is optional for some PDO
                          drivers.
  <info>array|null</info>   <strong>$options</strong>   A key=&gt;value array of driver-specific connection options.


id: PDO::beginTransaction
type: function
doc:
<comment>Description:</comment>
  Initiates a transaction
    
  
  Turns off autocommit mode.  While autocommit mode is turned off, changes made to the database via
  the PDO object instance are not committed until you end the transaction by calling PDO::commit.
  Calling PDO::rollBack will roll back all changes to the database and return the connection to
  autocommit mode.
  
  Some databases, including MySQL, automatically issue an implicit COMMIT when a database definition
  language (DDL) statement such as DROP TABLE or CREATE TABLE is issued within a transaction. The
  implicit COMMIT will prevent you from rolling back any other changes within the transaction
  boundary.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * PDO::commit
   * PDO::rollBack
   * Transactions and auto-commit


id: PDO::commit
type: function
doc:
<comment>Description:</comment>
  Commits a transaction
    
  
  Commits a transaction, returning the database connection to autocommit mode until the next call to
  PDO::beginTransaction starts a new transaction.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * PDO::beginTransaction
   * PDO::rollBack
   * Transactions and auto-commit


id: PDO::cubrid_schema
type: function
doc:
<comment>Description:</comment>
  Get the requested schema information
  
  This function is used to get the requested schema information from database. You have to designate
  <strong>$table_name</strong>, if you want to get information on certain table, <strong>$col_name</strong>, if you want to get
  information on certain column (can be used only with PDO::CUBRID_SCH_COL_PRIVILEGE).
  
  The result of this function is returned as a two-dimensional array (column (associative array) *
  row (numeric array)). The following tables shows types of schema and the column structure of the
  result array to be returned based on the schema type.
  
  Result Composition of Each TypeSchemaColumn NumberColumn
  NameValuePDO::CUBRID_SCH_TABLE1NAME2TYPE0:system table 1:view
  2:tablePDO::CUBRID_SCH_VIEW1NAME2TYPE1:viewPDO::CUBRID_SCH_QUERY_SPEC1QUERY_SPECPDO::CUBRID_SCH_ATTRIBUTE
  / PDO::CUBRID_SCH_TABLE_ATTRIBUTE1ATTR_NAME2DOMAIN3SCALE4PRECISION5INDEXED1:indexed6NOT NULL1:not
  null7SHARED1:shared8UNIQUE1:unique9DEFAULT10ATTR_ORDERbase:111CLASS_NAME12SOURCE_CLASS13IS_KEY1:keyPDO::CUBRID_SCH_METHOD
  /
  PDO::CUBRID_SCH_TABLE_METHOD1NAME2RET_DOMAIN3ARG_DOMAINPDO::CUBRID_SCH_METHOD_FILE1METHOD_FILEPDO::CUBRID_SCH_SUPER_TABLE
  / PDO::CUBRID_SCH_DIRECT_SUPER_TABLE / PDO::CUBRID_SCH_SUB_TABLE1CLASS_NAME2TYPE0:system table
  1:view 2:tablePDO::CUBRID_SCH_CONSTRAINT1TYPE0:unique 1:index 2:reverse unique 3:reverse
  index2NAME3ATTR_NAME4NUM_PAGES5NUM_KEYS6PRIMARY_KEY1:primary
  key7KEY_ORDERbase:1PDO::CUBRID_SCH_TRIGGER1NAME2STATUS3EVENT4TARGET_CLASS5TARGET_ATTR6ACTION_TIME7ACTION8PRIORITY9CONDITION_TIME10CONDITIONPDO::CUBRID_SCH_TABLE_PRIVILEGE
  / PDO::CUBRID_SCH_COL_PRIVILEGE1CLASS_NAME /
  ATTR_NAME2PRIVILEGE3GRANTABLEPDO::CUBRID_SCH_PRIMARY_KEY1CLASS_NAME2ATTR_NAME3KEY_SEQbase:14KEY_NAMEPDO::CUBRID_SCH_IMPORTED_KEYS
  / PDO::CUBRID_SCH_EXPORTED_KEYS /
  PDO::CUBRID_SCH_CROSS_REFERENCE1PKTABLE_NAME2PKCOLUMN_NAME3FKTABLE_NAMEbase:14FKCOLUMN_NAME5KEY_SEQbase:16UPDATE_ACTION0:cascade
  1:restrict 2:no action 3:set null7DELETE_ACTION0:cascade 1:restrict 2:no action 3:set
  null8FK_NAME9PK_NAME

<comment>Param:</comment>
  <info>int</info>     <strong>$schema_type</strong>  Schema type that you want to know.
  <info>string</info>  <strong>$table_name</strong>   Table you want to know the schema of.
  <info>string</info>  <strong>$col_name</strong>     Column you want to know the schema of.

<comment>Return:</comment>
  <info>array</info>  Array containing the schema information, when process is successful;
         
         FALSE, when process is unsuccessful


id: PDO::errorCode
type: function
doc:
<comment>Description:</comment>
  Fetch the SQLSTATE associated with the last operation on the database handle

<comment>Return:</comment>
  <info>string|null</info>  Returns an SQLSTATE, a five characters alphanumeric identifier defined in the ANSI
               SQL-92 standard.  Briefly, an SQLSTATE consists of a two characters class value
               followed by a three characters subclass value. A class value of 01 indicates a
               warning and is accompanied by a return code of SQL_SUCCESS_WITH_INFO. Class values
               other than '01', except for the class 'IM', indicate an error.  The class 'IM' is
               specific to warnings and errors that derive from the implementation of PDO (or
               perhaps ODBC, if you're using the ODBC driver) itself.  The subclass value '000' in
               any class indicates that there is no subclass for that SQLSTATE.
               
               PDO::errorCode only retrieves error codes for operations performed directly on the
               database handle. If you create a PDOStatement object through PDO::prepare or
               PDO::query and invoke an error on the statement handle, PDO::errorCode will not
               reflect that error. You must call PDOStatement::errorCode to return the error code
               for an operation performed on a particular statement handle.
               
               Returns <info>null</info> if no operation has been run on the database handle.

<comment>See Also:</comment>
   * PDO::errorInfo
   * PDOStatement::errorCode
   * PDOStatement::errorInfo


id: PDO::errorInfo
type: function
doc:
<comment>Description:</comment>
  Fetch extended error information associated with the last operation on the database handle

<comment>Return:</comment>
  <info>array</info>  PDO::errorInfo returns an array of error information about the last operation performed by
         this database handle. The array consists of at least the following fields:
         ElementInformation0SQLSTATE error code (a five characters alphanumeric identifier defined
         in the ANSI SQL standard).1Driver-specific error code.2Driver-specific error message.
         
         If the SQLSTATE error code is not set or there is no driver-specific error, the elements
         following element 0 will be set to <info>null</info>.
         
         PDO::errorInfo only retrieves error information for operations performed directly on the
         database handle. If you create a PDOStatement object through PDO::prepare or PDO::query and
         invoke an error on the statement handle, PDO::errorInfo will not reflect the error from the
         statement handle. You must call PDOStatement::errorInfo to return the error information for
         an operation performed on a particular statement handle.

<comment>See Also:</comment>
   * PDO::errorCode
   * PDOStatement::errorCode
   * PDOStatement::errorInfo


id: PDO::exec
type: function
doc:
<comment>Description:</comment>
  Execute an SQL statement and return the number of affected rows
    
  
  PDO::exec executes an SQL statement in a single function call, returning the number of rows
  affected by the statement.
  
  PDO::exec does not return results from a SELECT statement. For a SELECT statement that you only
  need to issue once during your program, consider issuing PDO::query. For a statement that you need
  to issue multiple times, prepare  a PDOStatement object with PDO::prepare and issue the statement
  with PDOStatement::execute.

<comment>Param:</comment>
  <info>string</info>  <strong>$statement</strong>  The SQL statement to prepare and execute.
                      
                      Data inside the query should be properly escaped.

<comment>Return:</comment>
  <info>int|false</info>  PDO::exec returns the number of rows that were modified or deleted by the SQL statement
             you issued. If no rows were affected,  PDO::exec returns <return>0</return>.
             
             This function may
             return Boolean <info>false</info>, but may also return a non-Boolean value which
             evaluates to <info>false</info>. Please read the section on Booleans for more
             information. Use the ===
             operator for testing the return value of this
             function.
             
             The following example incorrectly relies on the return value of PDO::exec, wherein a
             statement that affected 0 rows results in a call to <strong>die()</strong>: exec() or
             die(print_r($db->errorInfo(), true)); // incorrect
             ?>
             ]]>

<comment>See Also:</comment>
   * PDO::prepare
   * PDO::query
   * PDOStatement::execute


id: PDO::getAttribute
type: function
doc:
<comment>Description:</comment>
  Retrieve a database connection attribute
    
  
  This function returns the value of a database connection attribute. To retrieve PDOStatement
  attributes, refer to PDOStatement::getAttribute.
  
  Note that some database/driver combinations may not support all of the database connection
  attributes.

<comment>Param:</comment>
  <info>int</info>  <strong>$attribute</strong>  One of the <return>PDO::ATTR_*</return> constants. The generic attributes that apply to database
                   connections are as follows:
                   <return>PDO::ATTR_AUTOCOMMIT</return><return>PDO::ATTR_CASE</return><return>PDO::ATTR_CLIENT_VERSION</return><return>PDO::ATTR_CONNECTION_STATUS</return><return>PDO::ATTR_DRIVER_NAME</return><return>PDO::ATTR_ERRMODE</return><return>PDO::ATTR_ORACLE_NULLS</return><return>PDO::ATTR_PERSISTENT</return><return>PDO::ATTR_PREFETCH</return><return>PDO::ATTR_SERVER_INFO</return><return>PDO::ATTR_SERVER_VERSION</return><return>PDO::ATTR_TIMEOUT</return>
                   
                   Some drivers may make use of additional driver specific attributes. Note that
                   driver specific attributes must not be used with other drivers.

<comment>Return:</comment>
  <info>mixed</info>  A successful call returns the value of the requested PDO attribute. An unsuccessful call
         returns <return>null</return>.

<comment>See Also:</comment>
   * PDO::setAttribute
   * PDOStatement::getAttribute
   * PDOStatement::setAttribute


id: PDO::getAvailableDrivers
type: function
doc:
<comment>Description:</comment>
  Return an array of available PDO drivers
    
  
  This function returns all currently available PDO drivers which can be used in <strong>$DSN</strong> parameter of
  PDO::__construct.

<comment>Return:</comment>
  <info>array</info>  PDO::getAvailableDrivers returns an array of PDO driver names. If no drivers are available,
         it returns an empty array.


id: PDO::inTransaction
type: function
doc:
<comment>Description:</comment>
  Checks if inside a transaction
    
  
  Checks if a transaction is currently active within the driver. This method only works for database
  drivers that support transactions.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> if a transaction is currently active, and <info>false</info> if not.


id: PDO::lastInsertId
type: function
doc:
<comment>Description:</comment>
  Returns the ID of the last inserted row or sequence value
    
  
  Returns the ID of the last inserted row, or the last value from a sequence object, depending on
  the underlying driver. For example, PDO_PGSQL allows the name of any sequence object to be
  specified for the <strong>$name</strong> parameter.
  
  This method may not return a meaningful or consistent result across different PDO drivers, because
  the underlying database may not even support the notion of auto-increment fields or sequences.

<comment>Param:</comment>
  <info>string|null</info>  <strong>$name</strong>  Name of the sequence object from which the ID should be returned.

<comment>Return:</comment>
  <info>string|false</info>  If a sequence name was not specified for the <strong>$name</strong> parameter, PDO::lastInsertId
                returns a string representing the row ID of the last row that was inserted into the
                database.
                
                If a sequence name was specified for the <strong>$name</strong> parameter, PDO::lastInsertId returns
                a string representing the last value retrieved from the specified sequence object.
                
                If the PDO driver does not support this capability, PDO::lastInsertId triggers an
                <return>IM001</return> SQLSTATE.


id: PDO::pgsqlCopyFromArray
type: function
doc:
<comment>Description:</comment>
  Copy data from PHP array into table
  
  Copies data from <strong>$rows</strong> array to table <strong>$table_name</strong> using <strong>$delimiter</strong> as fields delimiter and <strong>$fields</strong>
  list

<comment>Param:</comment>
  <info>string</info>  <strong>$table_name</strong>  String containing table name
  <info>array</info>   <strong>$rows</strong>        Array of strings with fields separated by <strong>$delimiter</strong>
  <info>string</info>  <strong>$delimiter</strong>   Delimiter used in <strong>$rows</strong> array
  <info>string</info>  <strong>$null_as</strong>     How to interpret null values
  <info>string</info>  <strong>$fields</strong>      List of fields to insert

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success, or <info>false</info> on failure.


id: PDO::pgsqlCopyFromFile
type: function
doc:
<comment>Description:</comment>
  Copy data from file into table
  
  Copies data from file specified by <strong>$filename</strong> into table <strong>$table_name</strong> using <strong>$delimiter</strong> as fields
  delimiter and <strong>$fields</strong> list

<comment>Param:</comment>
  <info>string</info>  <strong>$table_name</strong>  String containing table name
  <info>string</info>  <strong>$filename</strong>    Filename containing data to import
  <info>string</info>  <strong>$delimiter</strong>   Delimiter used in file specified by <strong>$filename</strong>
  <info>string</info>  <strong>$null_as</strong>     How to interpret null values
  <info>string</info>  <strong>$fields</strong>      List of fields to insert

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success, or <info>false</info> on failure.


id: PDO::pgsqlCopyToArray
type: function
doc:
<comment>Description:</comment>
  Copy data from database table into PHP array
  
  Copies data from <strong>$table</strong> into array using <strong>$delimiter</strong> as fields delimiter and <strong>$fields</strong> list

<comment>Param:</comment>
  <info>string</info>  <strong>$table_name</strong>  String containing table name
  <info>string</info>  <strong>$delimiter</strong>   Delimiter used in rows
  <info>string</info>  <strong>$null_as</strong>     How to interpret null values
  <info>string</info>  <strong>$fields</strong>      List of fields to export

<comment>Return:</comment>
  <info>array|false</info>  Returns an array of rows, or <info>false</info> on failure.


id: PDO::pgsqlCopyToFile
type: function
doc:
<comment>Description:</comment>
  Copy data from table into file
  
  Copies data from table into file specified by <strong>$filename</strong> using <strong>$delimiter</strong> as fields delimiter and
  <strong>$fields</strong> list

<comment>Param:</comment>
  <info>string</info>  <strong>$table_name</strong>  String containing table name
  <info>string</info>  <strong>$filename</strong>    Filename to export data
  <info>string</info>  <strong>$delimiter</strong>   Delimiter used in file specified by <strong>$filename</strong>
  <info>string</info>  <strong>$null_as</strong>     How to interpret null values
  <info>string</info>  <strong>$fields</strong>      List of fields to insert

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success, or <info>false</info> on failure.


id: PDO::pgsqlGetNotify
type: function
doc:
<comment>Description:</comment>
  Get asynchronous notification
  
  Returns a result set representing a pending asynchronous notification.

<comment>Param:</comment>
  <info>int</info>  <strong>$result_type</strong>  The format the result set should be returned as, represented as a <info>PDO::FETCH_*</info>
                     constant.
  <info>int</info>  <strong>$ms_timeout</strong>   The length of time to wait for a response, in milliseconds.

<comment>Return:</comment>
  <info>array|false</info>  If one or more notifications is pending, returns a single row, with fields <return>message</return>
               and <return>pid</return>, otherwise returns <info>false</info>.


id: PDO::pgsqlGetPid
type: function
doc:
<comment>Description:</comment>
  Get the server PID
  
  Returns the server's PID.

<comment>Return:</comment>
  <info>int</info>  The server's PID.


id: PDO::pgsqlLOBCreate
type: function
doc:
<comment>Description:</comment>
  Creates a new large object
  
  <strong>PDO::pgsqlLOBCreate()</strong> creates a large object and returns the OID of that object.  You may then
  open a stream on the object using <strong>PDO::pgsqlLOBOpen()</strong> to read or write data to it.  The OID can be
  stored in columns of type OID and be used to reference the large object, without causing the row
  to grow arbitrarily large. The large object will continue to live in the database until it is
  removed by calling <strong>PDO::pgsqlLOBUnlink()</strong>.
  
  Large objects can be up to 2GB in size, but are cumbersome to use; you need to ensure that
  <strong>PDO::pgsqlLOBUnlink()</strong> is called prior to deleting the last row that references its OID from your
  database. In addition, large objects have no access controls.  As an alternative, try the bytea
  column type; recent versions of PostgreSQL allow bytea columns of up to 1GB in size and
  transparently manage the storage for optimal row size.
  
  This function must be called within a transaction.

<comment>Return:</comment>
  <info>string</info>  Returns the OID of the newly created large object on success, or <info>false</info> on failure.

<comment>See Also:</comment>
   * <strong>PDO::pgsqlLOBOpen()</strong>
   * <strong>PDO::pgsqlLOBUnlink()</strong>
   * <strong>pg_lo_create()</strong>


id: PDO::pgsqlLOBOpen
type: function
doc:
<comment>Description:</comment>
  Opens an existing large object stream
  
  <strong>PDO::pgsqlLOBOpen()</strong> opens a stream to access the data referenced by <strong>$oid</strong>.  If <strong>$mode</strong> is <return>r</return>, the
  stream is opened for reading, if <strong>$mode</strong> is <return>w</return>, then the stream will be opened for writing.  You can
  use all the usual filesystem functions, such as <strong>fread()</strong>, <strong>fwrite()</strong> and <strong>fgets()</strong> to manipulate the
  contents of the stream.
  
  This function, and all manipulations of the large object, must be called and carried out within a
  transaction.

<comment>Param:</comment>
  <info>string</info>  <strong>$oid</strong>   A large object identifier.
  <info>string</info>  <strong>$mode</strong>  If mode is <return>r</return>, open the stream for reading. If mode is <return>w</return>, open the stream for
                 writing.

<comment>Return:</comment>
  <info>resource|false</info>  Returns a stream resource on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * <strong>PDO::pgsqlLOBCreate()</strong>
   * <strong>PDO::pgsqlLOBUnlink()</strong>
   * <strong>pg_lo_open()</strong>


id: PDO::pgsqlLOBUnlink
type: function
doc:
<comment>Description:</comment>
  Deletes the large object
  
  Deletes a large object from the database identified by OID.
  
  This function must be called within a transaction.

<comment>Param:</comment>
  <info>string</info>  <strong>$oid</strong>  A large object identifier

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * <strong>PDO::pgsqlLOBOpen()</strong>
   * <strong>PDO::pgsqlLOBCreate()</strong>


id: PDO::prepare
type: function
doc:
<comment>Description:</comment>
  Prepares a statement for execution and returns a statement object
    
  
  Prepares an SQL statement to be executed by the PDOStatement::execute method. The statement
  template can contain zero or more named (:name) or question mark (?) parameter markers for which
  real values will be substituted when the statement is executed. Both named and question mark
  parameter markers cannot be used within the same statement template; only one or the other
  parameter style. Use these parameters to bind any user-input, do not include the user-input
  directly in the query.
  
  You must include a unique parameter marker for each value you wish to pass in to the statement
  when you call PDOStatement::execute. You cannot use a named parameter marker of the same name more
  than once in a prepared statement, unless emulation mode is on.
  
  Parameter markers can represent a complete data literal only. Neither part of literal, nor
  keyword, nor identifier, nor whatever arbitrary query  part can be bound using parameters. For
  example, you cannot bind multiple values  to a single parameter in the IN() clause of an SQL
  statement.
  
  Calling PDO::prepare and PDOStatement::execute for statements that will be issued multiple times
  with different parameter values optimizes the performance of your application by allowing the
  driver to negotiate client and/or server side caching of the query plan and meta information.
  Also, calling PDO::prepare and PDOStatement::execute helps to prevent SQL injection attacks by
  eliminating the need to manually quote and escape the parameters.
  
  PDO will emulate prepared statements/bound parameters for drivers that do not natively support
  them, and can also rewrite named or question mark style parameter markers to something more
  appropriate, if the driver supports one style but not the other.
  
  The parser used for emulated prepared statements and for rewriting named or question mark style
  parameters supports the non standard backslash escapes for single- and double quotes. That means
  that terminating quotes immediately preceeded by a backslash are not recognized as such, which may
  result in wrong detection of parameters causing the prepared statement to fail when it is
  executed. A work-around is to not use emulated prepares for such SQL queries, and to avoid
  rewriting of parameters by using a parameter style which is natively supported by the driver.
  
  As of PHP 7.4.0, question marks can be escaped by doubling them. That means that the <return>??</return> string
  will be translated to <return>?</return> when sending the query to the database.

<comment>Param:</comment>
  <info>string</info>  <strong>$query</strong>    This must be a valid SQL statement template for the target database server.
  <info>array</info>   <strong>$options</strong>  This array holds one or more key=&gt;value pairs to set attribute values for the
                    PDOStatement object that this method returns. You would most commonly use this
                    to set the <return>PDO::ATTR_CURSOR</return> value to <return>PDO::CURSOR_SCROLL</return> to request a scrollable
                    cursor. Some drivers have driver-specific options that may be set at
                    prepare-time.

<comment>Return:</comment>
  <info>PDOStatement|false</info>  If the database server successfully prepares the statement, PDO::prepare
                      returns a <class>PDOStatement</class> object. If the database server cannot successfully
                      prepare the statement, PDO::prepare returns <info>false</info> or emits <class>PDOException</class>
                      (depending on error handling).
                      
                      Emulated prepared statements does not communicate with the database server so
                      PDO::prepare does not check the statement.

<comment>See Also:</comment>
   * PDO::exec
   * PDO::query
   * PDOStatement::execute


id: PDO::query
type: function
doc:
<comment>Description:</comment>
  Prepares and executes an SQL statement without placeholders
    
  
  PDO::query prepares and executes an SQL statement in a single function call, returning the
  statement as a <class>PDOStatement</class> object.
  
  For a query that you need to issue multiple times, you will realize better performance if you
  prepare a <class>PDOStatement</class> object using PDO::prepare and issue the statement with multiple calls to
  PDOStatement::execute.
  
  If you do not fetch all of the data in a result set before issuing your next call to PDO::query,
  your call may fail. Call PDOStatement::closeCursor to release the database resources associated
  with the <class>PDOStatement</class> object before issuing your next call to PDO::query.
  
  If the <strong>$query</strong> contains placeholders, the statement must be prepared and executed separately using
  PDO::prepare and  PDOStatement::execute methods.

<comment>Param:</comment>
  <info>string</info>    <strong>$query</strong>      The SQL statement to prepare and execute.
                        
                        If the SQL contains placeholders, PDO::prepare and  PDOStatement::execute
                        must be used instead. Alternatively, the SQL can be prepared manually before
                        calling  PDO::query, with the data properly formatted using PDO::quote if
                        the driver supports it.
  <info>int|null</info>  <strong>$fetchMode</strong>  The default fetch mode for the returned <class>PDOStatement</class>. It must be one of the
                        <return>PDO::FETCH_*</return> constants.
                        
                        If this argument is passed to the function, the remaining arguments will be
                        treated as though PDOStatement::setFetchMode was called on the resultant
                        statement object. The subsequent arguments vary depending on the selected
                        fetch mode.

<comment>Return:</comment>
  <info>PDOStatement|false</info>  Returns a <class>PDOStatement</class> object or <info>false</info> on failure.

<comment>See Also:</comment>
   * PDO::exec
   * PDO::prepare
   * PDOStatement::execute


id: PDO::quote
type: function
doc:
<comment>Description:</comment>
  Quotes a string for use in a query
    
  
  PDO::quote places quotes around the input string (if required) and escapes special characters
  within the input string, using a quoting style appropriate to the underlying driver.
  
  If you are using this function to build SQL statements, you are strongly recommended to use
  PDO::prepare to prepare SQL statements with bound parameters instead of using PDO::quote to
  interpolate user input into an SQL statement.  Prepared statements with bound parameters are not
  only more portable, more convenient, immune to SQL injection, but are often much faster to execute
  than interpolated queries, as both the server and client side can cache a compiled form of the
  query.
  
  Not all PDO drivers implement this method (notably PDO_ODBC).  Consider using prepared statements
  instead.
  
  The character set must be set either on the server level, or within the database connection itself
  (depending on the driver) for it to affect PDO::quote. See the driver-specific documentation for
  more information.

<comment>Param:</comment>
  <info>string</info>  <strong>$string</strong>  The string to be quoted.
  <info>int</info>     <strong>$type</strong>    Provides a hint to  the type of data for drivers that have alternate quoting
                   styles. For example <info>PDO_PARAM_LOB</info> will tell the driver to escape binary data.

<comment>Return:</comment>
  <info>string|false</info>  Returns a quoted string that is theoretically safe to pass into an SQL statement.
                Returns <info>false</info> if the driver does not support quoting in this way.

<comment>See Also:</comment>
   * PDO::prepare
   * PDOStatement::execute


id: PDO::rollBack
type: function
doc:
<comment>Description:</comment>
  Rolls back a transaction
    
  
  Rolls back the current transaction, as initiated by PDO::beginTransaction.
  
  If the database was set to autocommit mode, this function will restore autocommit mode after it
  has rolled back the transaction.
  
  Some databases, including MySQL, automatically issue an implicit COMMIT when a database definition
  language (DDL) statement such as DROP TABLE or CREATE TABLE is issued within a transaction. The
  implicit COMMIT will prevent you from rolling back any other changes within the transaction
  boundary.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * PDO::beginTransaction
   * PDO::commit
   * Transactions and auto-commit


id: PDO::setAttribute
type: function
doc:
<comment>Description:</comment>
  Set an attribute
    
  
  Sets an attribute on the database handle. Some available generic attributes are listed below; some
  drivers may make use of additional driver specific attributes. Note that driver specific
  attributes must not be used with other drivers. <info>PDO::ATTR_CASE</info> Force column names to a specific
  case. Can take one of the following values: <info>PDO::CASE_LOWER</info> Force column names to lower case.
  <info>PDO::CASE_NATURAL</info> Leave column names as returned by the database driver. <info>PDO::CASE_UPPER</info> Force
  column names to upper case. <info>PDO::ATTR_ERRMODE</info> Error reporting mode of PDO. Can take one of the
  following values: <info>PDO::ERRMODE_SILENT</info> Only sets error codes. <info>PDO::ERRMODE_WARNING</info> Raises <info>E_WARNING</info>
  diagnostics. <info>PDO::ERRMODE_EXCEPTION</info> Throws <class>PDOException</class>s. <info>PDO::ATTR_ORACLE_NULLS</info> This attribute is
  available with all drivers, not just Oracle.  Determines if and how <info>null</info> and empty strings should
  be converted. Can take one of the following values: <info>PDO::NULL_NATURAL</info> No conversion takes place.
  <info>PDO::NULL_EMPTY_STRING</info> Empty strings get converted to <info>null</info>. <info>PDO::NULL_TO_STRING</info><info>null</info> gets converted
  to an empty string. <info>PDO::ATTR_STRINGIFY_FETCHES</info> Whether to convert numeric values to strings when
  fetching. Takes a value of type <info>bool</info>: <info>true</info> to enable and <info>false</info> to disable.
  <info>PDO::ATTR_STATEMENT_CLASS</info> Set user-supplied statement class derived from PDOStatement.  Requires
  <return>array(string classname, array(mixed constructor_args))</return>.  Cannot be used with persistent PDO
  instances. <info>PDO::ATTR_TIMEOUT</info> Specifies the timeout duration in seconds. Takes a value of type <info>int</info>.
  Not all drivers support this option, and its meaning may differ from driver to driver. For
  example, SQLite will wait for up to this time value before giving up on obtaining a writable lock,
  but other drivers may interpret this as a connection or a read timeout interval.
  <info>PDO::ATTR_AUTOCOMMIT</info> Only available for the OCI, Firebird, and MySQL drivers.  Whether to
  autocommit every single statement. Takes a value of type <info>bool</info>: <info>true</info> to enable and <info>false</info> to
  disable. By default, <info>true</info>. <info>PDO::ATTR_EMULATE_PREPARES</info> Only available for the OCI, Firebird, and
  MySQL drivers.  Whether enable or disable emulation of prepared statements. Some drivers do not
  support prepared statements natively or have limited support for them. If set to <info>true</info> PDO will
  always emulate prepared statements, otherwise PDO will attempt to use native prepared statements.
  In case the driver cannot successfully prepare the current query, PDO will always fall back to
  emulating the prepared statement. <info>PDO::MYSQL_ATTR_USE_BUFFERED_QUERY</info> Only available for the MySQL
  driver.  Whether to use buffered queries. Takes a value of type <info>bool</info>: <info>true</info> to enable and <info>false</info> to
  disable. By default, <info>true</info>. <info>PDO::ATTR_DEFAULT_FETCH_MODE</info> Set the default fetch mode. A description
  of the modes and how to use them is available in the PDOStatement::fetch documentation.
  
  Force column names to a specific case. Can take one of the following values:
  
  Force column names to lower case.
  
  Leave column names as returned by the database driver.
  
  Force column names to upper case.
  
  Error reporting mode of PDO. Can take one of the following values:
  
  Only sets error codes.
  
  Raises <info>E_WARNING</info> diagnostics.
  
  Throws <class>PDOException</class>s.
  
  This attribute is available with all drivers, not just Oracle.
  
  Determines if and how <info>null</info> and empty strings should be converted. Can take one of the following
  values:
  
  No conversion takes place.
  
  Empty strings get converted to <info>null</info>.
  
  <info>null</info> gets converted to an empty string.
  
  Whether to convert numeric values to strings when fetching. Takes a value of type <info>bool</info>: <info>true</info> to
  enable and <info>false</info> to disable.
  
  Set user-supplied statement class derived from PDOStatement.  Requires <return>array(string classname,
  array(mixed constructor_args))</return>.
  
  Cannot be used with persistent PDO instances.
  
  Specifies the timeout duration in seconds. Takes a value of type <info>int</info>.
  
  Not all drivers support this option, and its meaning may differ from driver to driver. For
  example, SQLite will wait for up to this time value before giving up on obtaining a writable lock,
  but other drivers may interpret this as a connection or a read timeout interval.
  
  Only available for the OCI, Firebird, and MySQL drivers.
  
  Whether to autocommit every single statement. Takes a value of type <info>bool</info>: <info>true</info> to enable and <info>false</info>
  to disable. By default, <info>true</info>.
  
  Only available for the OCI, Firebird, and MySQL drivers.
  
  Whether enable or disable emulation of prepared statements. Some drivers do not support prepared
  statements natively or have limited support for them. If set to <info>true</info> PDO will always emulate
  prepared statements, otherwise PDO will attempt to use native prepared statements. In case the
  driver cannot successfully prepare the current query, PDO will always fall back to emulating the
  prepared statement.
  
  Only available for the MySQL driver.
  
  Whether to use buffered queries. Takes a value of type <info>bool</info>: <info>true</info> to enable and <info>false</info> to disable.
  By default, <info>true</info>.
  
  Set the default fetch mode. A description of the modes and how to use them is available in the
  PDOStatement::fetch documentation.

<comment>Param:</comment>
  <info>int</info>    <strong>$attribute</strong>  The attribute to modify.
  <info>mixed</info>  <strong>$value</strong>      The value to set the <strong>$attribute</strong>, might require a specific type depending on the
                     attribute.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * <strong>PDO::getAttribute()</strong>
   * <strong>PDOStatement::getAttribute()</strong>
   * <strong>PDOStatement::setAttribute()</strong>


id: PDO::sqliteCreateAggregate
type: function
doc:
<comment>Description:</comment>
  Registers an aggregating User Defined Function for use in SQL statements
    
  
  This function is
  EXPERIMENTAL. The behaviour of this function, its name, and
  surrounding documentation may change without notice in a future release of PHP.
  This function should be used at your own risk.
  
  This method is similar to  except that it registers functions that can be used to calculate a
  result aggregated across all the rows of a query.
  
  The key difference between this method and  is that two functions are required to manage the
  aggregate.

<comment>Param:</comment>
  <info>string</info>    <strong>$function_name</strong>  The name of the function used in SQL statements.
  <info>callable</info>  <strong>$step_func</strong>      Callback function called for each row of the result set. Your PHP
                            function should accumulate the result and store it in the aggregation
                            context.
                            
                            This function need to be defined as:
                            <info>mixed</info>step<info>mixed</info><strong>$context</strong><info>int</info><strong>$rownumber</strong><info>mixed</info><strong>$value</strong><info>mixed</info><strong>$values</strong> <strong>$context</strong><info>null</info>
                            for the first row; on subsequent rows it will have the value that was
                            previously returned from the step function; you should use this to
                            maintain the aggregate state. <strong>$rownumber</strong> The current row number. <strong>$value</strong>
                            The first argument passed to the aggregate. <strong>$values</strong> Further arguments
                            passed to the aggregate.  The return value of this function will be used
                            as the <strong>$context</strong> argument in the next call of the step or finalize
                            functions.
                            
                            <info>null</info> for the first row; on subsequent rows it will have the value that
                            was previously returned from the step function; you should use this to
                            maintain the aggregate state.
                            
                            The current row number.
                            
                            The first argument passed to the aggregate.
                            
                            Further arguments passed to the aggregate.
  <info>mixed</info>     <strong>$context</strong>        <info>null</info> for the first row; on subsequent rows it will have the value that
                            was previously returned from the step function; you should use this to
                            maintain the aggregate state.
  <info>int</info>       <strong>$rownumber</strong>      The current row number.
  <info>mixed</info>     <strong>$value</strong>          The first argument passed to the aggregate.
  <info>mixed</info>     <strong>$values</strong>         Further arguments passed to the aggregate.
  <info>callable</info>  <strong>$finalize_func</strong>  Callback function to aggregate the "stepped" data from each row.  Once
                            all the rows have been processed, this function will be called and it
                            should then take the data from the aggregation context and return the
                            result. This callback function should return a type understood by SQLite
                            (i.e. scalar type).
                            
                            This function need to be defined as: <info>mixed</info>fini<info>mixed</info><strong>$context</strong><info>int</info><strong>$rowcount</strong>
                            <strong>$context</strong> Holds the return value from the very last call to the step
                            function. <strong>$rowcount</strong> Holds the number of rows over which the aggregate
                            was performed.  The return value of this function will be used as the
                            return value for the aggregate.
                            
                            Holds the return value from the very last call to the step function.
                            
                            Holds the number of rows over which the aggregate was performed.
  <info>mixed</info>     <strong>$context</strong>        Holds the return value from the very last call to the step function.
  <info>int</info>       <strong>$rowcount</strong>       Holds the number of rows over which the aggregate was performed.
  <info>int</info>       <strong>$num_args</strong>       Hint to the SQLite parser if the callback function accepts a
                            predetermined number of arguments.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * 
   * <strong>sqlite_create_function()</strong>
   * <strong>sqlite_create_aggregate()</strong>


id: PDO::sqliteCreateCollation
type: function
doc:
<comment>Description:</comment>
  Registers a User Defined Function for use as a collating function in SQL statements
    
  
  This function is
  EXPERIMENTAL. The behaviour of this function, its name, and
  surrounding documentation may change without notice in a future release of PHP.
  This function should be used at your own risk.

<comment>Param:</comment>
  <info>string</info>    <strong>$name</strong>      Name of the SQL collating function to be created or redefined.
  <info>callable</info>  <strong>$callback</strong>  The name of a PHP function or user-defined function to apply as a callback,
                       defining the behavior of the collation. It should accept two strings and
                       return as strcmp() does, i.e. it should return -1, 1, or 0 if the first
                       string sorts before, sorts after, or is equal to the second.
                       
                       This function need to be defined as: <info>int</info>collation<info>string</info><strong>$string1</strong><info>string</info><strong>$string2</strong>

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.


id: PDO::sqliteCreateFunction
type: function
doc:
<comment>Description:</comment>
  Registers a User Defined Function for use in SQL statements
    
  
  This function is
  EXPERIMENTAL. The behaviour of this function, its name, and
  surrounding documentation may change without notice in a future release of PHP.
  This function should be used at your own risk.
  
  This method allows you to register a PHP function with SQLite as an  UDF (User Defined Function),
  so that it can be called from within your SQL statements.
  
  The UDF can be used in any SQL statement that can call functions, such as SELECT and UPDATE
  statements and also in triggers.

<comment>Param:</comment>
  <info>string</info>    <strong>$function_name</strong>  The name of the function used in SQL statements.
  <info>callable</info>  <strong>$callback</strong>       Callback function to handle the defined SQL function.
                            
                            Callback functions should return a type understood by SQLite (i.e.
                            scalar type).
                            
                            This function need to be defined as:
                            <info>mixed</info>callback<info>mixed</info><strong>$value</strong><info>mixed</info><strong>$values</strong> <strong>$value</strong> The first argument passed to
                            the SQL function. <strong>$values</strong> Further arguments passed to the SQL function.
                            
                            The first argument passed to the SQL function.
                            
                            Further arguments passed to the SQL function.
  <info>mixed</info>     <strong>$value</strong>          The first argument passed to the SQL function.
  <info>mixed</info>     <strong>$values</strong>         Further arguments passed to the SQL function.
  <info>int</info>       <strong>$num_args</strong>       The number of arguments that the SQL function takes. If this parameter
                            is <return>-1</return>, then the SQL function may take any number of arguments.
  <info>int</info>       <strong>$flags</strong>          A bitwise conjunction of flags. Currently, only
                            <info>PDO::SQLITE_DETERMINISTIC</info> is supported, which specifies that the
                            function always returns the same result given the same inputs within a
                            single SQL statement.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * 
   * <strong>sqlite_create_function()</strong>
   * <strong>sqlite_create_aggregate()</strong>


id: PDOStatement
type: class
doc:
<comment>Description:</comment>
  Represents a prepared statement and, after the statement is executed, an  associated result set.


id: PDOStatement::bindColumn
type: function
doc:
<comment>Description:</comment>
  Bind a column to a PHP variable
    
  
  PDOStatement::bindColumn arranges to have a particular variable bound to a given column in the
  result-set from a query.  Each call to PDOStatement::fetch or PDOStatement::fetchAll will update
  all the variables that are bound to columns.
  
  Since information about the columns is not always available to PDO until the statement is
  executed, portable applications should call this function after PDOStatement::execute.
  
  However, to be able to bind a LOB column as a stream when using the PgSQL driver, applications
  should call this method before calling PDOStatement::execute, otherwise the large object OID will
  be returned as an integer.

<comment>Param:</comment>
  <info>string|int</info>  <strong>$column</strong>         Number of the column (1-indexed) or name of the column in the result
                              set. If using the column name, be aware that the name should match the
                              case of the column, as returned by the driver.
  <info>mixed</info>       <strong>$var</strong>            Name of the PHP variable to which the column will be bound.
  <info>int</info>         <strong>$type</strong>           Data type of the parameter, specified by the <return>PDO::PARAM_*</return> constants.
  <info>int</info>         <strong>$maxLength</strong>      A hint for pre-allocation.
  <info>mixed</info>       <strong>$driverOptions</strong>  Optional parameter(s) for the driver.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * PDOStatement::execute
   * PDOStatement::fetch
   * PDOStatement::fetchAll
   * PDOStatement::fetchColumn


id: PDOStatement::bindParam
type: function
doc:
<comment>Description:</comment>
  Binds a parameter to the specified variable name
    
  
  Binds a PHP variable to a corresponding named or question mark placeholder in the SQL statement
  that was used to prepare the statement.  Unlike PDOStatement::bindValue, the variable is bound as
  a reference and will only be evaluated at the time that PDOStatement::execute is called.
  
  Most parameters are input parameters, that is, parameters that are used in a read-only fashion to
  build up the query (but may nonetheless be cast according to <strong>$type</strong>).  Some drivers support the
  invocation of stored procedures that return data as output parameters, and some also as
  input/output parameters that both send in data and are updated to receive it.

<comment>Param:</comment>
  <info>string|int</info>  <strong>$param</strong>          Parameter identifier. For a prepared statement using named
                              placeholders, this will be a parameter name of the form :name. For a
                              prepared statement using question mark placeholders, this will be the
                              1-indexed position of the parameter.
  <info>mixed</info>       <strong>$var</strong>            Name of the PHP variable to bind to the SQL statement parameter.
  <info>int</info>         <strong>$type</strong>           Explicit data type for the parameter using the <return>PDO::PARAM_*</return> constants.
                              To return an INOUT parameter from a stored procedure,  use the bitwise
                              OR operator to set the <info>PDO::PARAM_INPUT_OUTPUT</info> bits for the <strong>$type</strong>
                              parameter.
  <info>int</info>         <strong>$maxLength</strong>      Length of the data type. To indicate that a parameter is an OUT
                              parameter from a stored procedure, you must explicitly set the length.
                              Meaningful only when <strong>$type</strong> parameter is <info>PDO::PARAM_INPUT_OUTPUT</info>.
  <info>mixed</info>       <strong>$driverOptions</strong>  

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * PDO::prepare
   * PDOStatement::execute
   * PDOStatement::bindValue


id: PDOStatement::bindValue
type: function
doc:
<comment>Description:</comment>
  Binds a value to a parameter
    
  
  Binds a value to a corresponding named or question mark placeholder in the SQL statement that was
  used to prepare the statement.

<comment>Param:</comment>
  <info>string|int</info>  <strong>$param</strong>  Parameter identifier. For a prepared statement using named placeholders, this
                      will be a parameter name of the form :name. For a prepared statement using
                      question mark placeholders, this will be the 1-indexed position of the
                      parameter.
  <info>mixed</info>       <strong>$value</strong>  The value to bind to the parameter.
  <info>int</info>         <strong>$type</strong>   Explicit data type for the parameter using the <return>PDO::PARAM_*</return> constants.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * PDO::prepare
   * PDOStatement::execute
   * PDOStatement::bindParam


id: PDOStatement::closeCursor
type: function
doc:
<comment>Description:</comment>
  Closes the cursor, enabling the statement to be executed again
    
  
  PDOStatement::closeCursor frees up the connection to the server so that other SQL statements may
  be issued, but leaves the statement in a state that enables it to be executed again.
  
  This method is useful for database drivers that do not support executing a PDOStatement object
  when a previously executed PDOStatement object still has unfetched rows. If your database driver
  suffers from this limitation, the problem may manifest itself in an out-of-sequence error.
  
  PDOStatement::closeCursor is implemented either as an optional driver specific method (allowing
  for maximum efficiency), or as the generic PDO fallback if no driver specific function is
  installed. The PDO generic fallback is semantically the same as writing the following code in your
  PHP script: fetch()) ; if (!$stmt->nextRowset()) break;
  } while (true);
  ?>
  ]]>

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * PDOStatement::execute


id: PDOStatement::columnCount
type: function
doc:
<comment>Description:</comment>
  Returns the number of columns in the result set
    
  
  Use PDOStatement::columnCount to return the number of columns in the result set represented by the
  PDOStatement object.
  
  If the PDOStatement object was returned from PDO::query, the column count is immediately
  available.
  
  If the PDOStatement object was returned from PDO::prepare, an accurate column count will not be
  available until you invoke PDOStatement::execute.

<comment>Return:</comment>
  <info>int</info>  Returns the number of columns in the result set represented by the PDOStatement object, even
       if the result set is empty. If there is no result set, PDOStatement::columnCount returns <return>0</return>.

<comment>See Also:</comment>
   * PDO::prepare
   * PDOStatement::execute
   * PDOStatement::rowCount


id: PDOStatement::debugDumpParams
type: function
doc:
<comment>Description:</comment>
  Dump an SQL prepared command
    
  
  Dumps the information contained by a prepared statement directly on the output. It will provide
  the <return>SQL</return> query in use, the  number of parameters used (<return>Params</return>), the list of parameters with their
  key name or position, their name, their position in the query (if this is supported by the PDO
  driver, otherwise, it will be -1), type (<return>param_type</return>) as an integer, and a boolean value <return>is_param</return>.
  
  This is a debug function, which dumps the data directly to the normal output.  As with anything
  that outputs
  its result directly to the browser, the output-control functions can be used to capture
  the output of this function, and save it in a
  <info>string</info> (for example).
  
  As with anything that outputs
  its result directly to the browser, the output-control functions can be used to capture
  the output of this function, and save it in a
  <info>string</info> (for example).
  
  This will only dump the parameters in the statement at the moment of the dump. Extra parameters
  are not stored in the statement, and not displayed.

<comment>Return:</comment>
  <info>bool|null</info>  Returns <info>null</info>, or <info>false</info> in case of an error.

<comment>See Also:</comment>
   * PDO::prepare
   * PDOStatement::bindParam
   * PDOStatement::bindValue


id: PDOStatement::errorCode
type: function
doc:
<comment>Description:</comment>
  Fetch the SQLSTATE associated with the last operation on the statement handle

<comment>Return:</comment>
  <info>string|null</info>  Identical to PDO::errorCode, except that  PDOStatement::errorCode only retrieves
               error codes for operations performed with PDOStatement objects.

<comment>See Also:</comment>
   * PDO::errorCode
   * PDO::errorInfo
   * PDOStatement::errorInfo


id: PDOStatement::errorInfo
type: function
doc:
<comment>Description:</comment>
  Fetch extended error information associated with the last operation on the statement handle

<comment>Return:</comment>
  <info>array</info>  PDOStatement::errorInfo returns an array of error information about the last operation
         performed by this statement handle. The array consists of at least the following fields:
         ElementInformation0SQLSTATE error code (a five characters alphanumeric identifier defined
         in the ANSI SQL standard).1Driver specific error code.2Driver specific error message.

<comment>See Also:</comment>
   * PDO::errorCode
   * PDO::errorInfo
   * PDOStatement::errorCode


id: PDOStatement::execute
type: function
doc:
<comment>Description:</comment>
  Executes a prepared statement
    
  
  Execute the prepared statement. If the prepared statement included parameter markers, either:
  PDOStatement::bindParam and/or PDOStatement::bindValue has to be called to bind either variables
  or values (respectively) to the parameter markers. Bound variables pass their value as input and
  receive the output value, if any, of their associated parameter markersor an array of input-only
  parameter values has to be passed
  
  PDOStatement::bindParam and/or PDOStatement::bindValue has to be called to bind either variables
  or values (respectively) to the parameter markers. Bound variables pass their value as input and
  receive the output value, if any, of their associated parameter markers
  
  or an array of input-only parameter values has to be passed

<comment>Param:</comment>
  <info>array|null</info>  <strong>$params</strong>  An array of values with as many elements as there are bound parameters in the
                       SQL statement being executed. All values are treated as <info>PDO::PARAM_STR</info>.
                       
                       Multiple values cannot be bound to a single parameter; for example, it is not
                       allowed to bind two values to a single named parameter in an IN() clause.
                       
                       Binding more values than specified is not possible; if more keys exist in
                       <strong>$params</strong> than in the SQL specified  in the PDO::prepare, then the statement
                       will  fail and an error is emitted.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * PDO::prepare
   * PDOStatement::bindParam
   * PDOStatement::fetch
   * PDOStatement::fetchAll
   * PDOStatement::fetchColumn


id: PDOStatement::fetch
type: function
doc:
<comment>Description:</comment>
  Fetches the next row from a result set
    
  
  Fetches a row from a result set associated with a PDOStatement object. The <strong>$mode</strong> parameter
  determines how PDO returns the row.

<comment>Param:</comment>
  <info>int</info>  <strong>$mode</strong>               Controls how the next row will be returned to the caller. This value must
                           be one of the <return>PDO::FETCH_*</return> constants, defaulting to value of
                           <return>PDO::ATTR_DEFAULT_FETCH_MODE</return> (which defaults to <return>PDO::FETCH_BOTH</return>).
                           <return>PDO::FETCH_ASSOC</return>: returns an array indexed by column name as returned in
                           your result set <return>PDO::FETCH_BOTH</return> (default): returns an array indexed by
                           both column name and 0-indexed column number as returned in your result
                           set <return>PDO::FETCH_BOUND</return>: returns <info>true</info> and assigns the values of the columns
                           in your result set to the PHP variables to which they were bound with the
                           PDOStatement::bindColumn method <return>PDO::FETCH_CLASS</return>: returns a new instance
                           of the requested class, mapping the columns of the result set to named
                           properties in the class, and calling the constructor afterwards, unless
                           <return>PDO::FETCH_PROPS_LATE</return> is also given. If <strong>$mode</strong> includes
                           PDO::FETCH_CLASSTYPE (e.g. <return>PDO::FETCH_CLASS | PDO::FETCH_CLASSTYPE</return>) then
                           the name of the class is determined from a value of the first column.
                           <return>PDO::FETCH_INTO</return>: updates an existing instance of the requested class,
                           mapping the columns of the result set to named properties in the class
                           <return>PDO::FETCH_LAZY</return>: combines <return>PDO::FETCH_BOTH</return> and <return>PDO::FETCH_OBJ</return>, creating
                           the object variable names as they are accessed <return>PDO::FETCH_NAMED</return>: returns
                           an array with the same form as <return>PDO::FETCH_ASSOC</return>, except that if there are
                           multiple columns with the same name, the value referred to by that key
                           will be an array of all the values in the row that had that column name
                           <return>PDO::FETCH_NUM</return>: returns an array indexed by column number as returned in
                           your result set, starting at column 0 <return>PDO::FETCH_OBJ</return>: returns an
                           anonymous object with property names that correspond to the column names
                           returned in your result set <return>PDO::FETCH_PROPS_LATE</return>: when used with
                           <return>PDO::FETCH_CLASS</return>, the constructor of the class is called before the
                           properties are assigned from the respective column values.
                           
                           <return>PDO::FETCH_ASSOC</return>: returns an array indexed by column name as returned in
                           your result set
                           
                           <return>PDO::FETCH_BOTH</return> (default): returns an array indexed by both column name
                           and 0-indexed column number as returned in your result set
                           
                           <return>PDO::FETCH_BOUND</return>: returns <info>true</info> and assigns the values of the columns in
                           your result set to the PHP variables to which they were bound with the
                           PDOStatement::bindColumn method
                           
                           <return>PDO::FETCH_CLASS</return>: returns a new instance of the requested class, mapping
                           the columns of the result set to named properties in the class, and
                           calling the constructor afterwards, unless <return>PDO::FETCH_PROPS_LATE</return> is also
                           given. If <strong>$mode</strong> includes PDO::FETCH_CLASSTYPE (e.g. <return>PDO::FETCH_CLASS |
                           PDO::FETCH_CLASSTYPE</return>) then the name of the class is determined from a
                           value of the first column.
                           
                           <return>PDO::FETCH_INTO</return>: updates an existing instance of the requested class,
                           mapping the columns of the result set to named properties in the class
                           
                           <return>PDO::FETCH_LAZY</return>: combines <return>PDO::FETCH_BOTH</return> and <return>PDO::FETCH_OBJ</return>, creating
                           the object variable names as they are accessed
                           
                           <return>PDO::FETCH_NAMED</return>: returns an array with the same form as
                           <return>PDO::FETCH_ASSOC</return>, except that if there are multiple columns with the same
                           name, the value referred to by that key will be an array of all the
                           values in the row that had that column name
                           
                           <return>PDO::FETCH_NUM</return>: returns an array indexed by column number as returned in
                           your result set, starting at column 0
                           
                           <return>PDO::FETCH_OBJ</return>: returns an anonymous object with property names that
                           correspond to the column names returned in your result set
                           
                           <return>PDO::FETCH_PROPS_LATE</return>: when used with <return>PDO::FETCH_CLASS</return>, the constructor
                           of the class is called before the properties are assigned from the
                           respective column values.
  <info>int</info>  <strong>$cursorOrientation</strong>  For a PDOStatement object representing a scrollable cursor, this value
                           determines which row will be returned to the caller. This value must be
                           one of the <return>PDO::FETCH_ORI_*</return> constants, defaulting to <return>PDO::FETCH_ORI_NEXT</return>.
                           To request a scrollable cursor for your PDOStatement object, you must set
                           the <return>PDO::ATTR_CURSOR</return> attribute to <return>PDO::CURSOR_SCROLL</return> when you prepare the
                           SQL statement with PDO::prepare.
  <info>int</info>  <strong>$cursorOffset</strong>       For a PDOStatement object representing a scrollable cursor for which the
                           <strong>$cursorOrientation</strong> parameter is set to <return>PDO::FETCH_ORI_ABS</return>, this value
                           specifies the absolute number of the row in the result set that shall be
                           fetched.
                           
                           For a PDOStatement object representing a scrollable cursor for which the
                           <strong>$cursorOrientation</strong> parameter is set to <return>PDO::FETCH_ORI_REL</return>, this value
                           specifies the row to fetch relative to the cursor position before
                           PDOStatement::fetch was called.

<comment>Return:</comment>
  <info>mixed</info>  The return value of this function on success depends on the fetch type. In all cases, <info>false</info>
         is returned on failure or if there are no more rows.

<comment>See Also:</comment>
   * PDO::prepare
   * PDOStatement::execute
   * PDOStatement::fetchAll
   * PDOStatement::fetchColumn
   * PDOStatement::fetchObject
   * PDOStatement::setFetchMode


id: PDOStatement::fetchAll
type: function
doc:
<comment>Description:</comment>
  Fetches the remaining rows from a result set

<comment>Param:</comment>
  <info>int</info>         <strong>$mode</strong>             Controls the contents of the returned array as documented in
                                PDOStatement::fetch. Defaults to value of
                                <info>PDO::ATTR_DEFAULT_FETCH_MODE</info> (which defaults to <info>PDO::FETCH_BOTH</info>)
                                
                                To return an array consisting of all values of a single column from
                                the result set, specify <info>PDO::FETCH_COLUMN</info>. You can specify which
                                column you want with the <strong>$column</strong> parameter.
                                
                                To fetch only the unique values of a single column from the result
                                set, bitwise-OR <info>PDO::FETCH_COLUMN</info> with <info>PDO::FETCH_UNIQUE</info>.
                                
                                To return an associative array grouped by the values of a specified
                                column, bitwise-OR <info>PDO::FETCH_COLUMN</info> with <info>PDO::FETCH_GROUP</info>.
  <info>int</info>         <strong>$column</strong>           Used with <info>PDO::FETCH_COLUMN</info>. Returns the indicated 0-indexed column.
  <info>string</info>      <strong>$class</strong>            Used with <info>PDO::FETCH_CLASS</info>. Returns instances of the specified
                                class, mapping the columns of each row to named properties in the
                                class.
  <info>array|null</info>  <strong>$constructorArgs</strong>  Arguments of custom class constructor when the <strong>$mode</strong>  parameter is
                                <info>PDO::FETCH_CLASS</info>.
  <info>callable</info>    <strong>$callback</strong>         Used with <info>PDO::FETCH_FUNC</info>. Returns the results of calling the
                                specified function, using each row's columns as parameters in the
                                call.

<comment>Return:</comment>
  <info>array</info>  PDOStatement::fetchAll returns an array containing all of the remaining rows in the result
         set. The array represents each row as either an array of column values or an object with
         properties corresponding to each column name. An empty array is returned if there are zero
         results to fetch.
         
         Using this method to fetch large result sets will result in a heavy demand on system and
         possibly network resources. Rather than retrieving all of the data and manipulating it in
         PHP, consider using the database server to manipulate the result sets. For example, use the
         WHERE and ORDER BY clauses in SQL to restrict results before retrieving and processing them
         with PHP.

<comment>See Also:</comment>
   * PDO::query
   * PDOStatement::fetch
   * PDOStatement::fetchColumn
   * PDO::prepare
   * PDOStatement::setFetchMode


id: PDOStatement::fetchColumn
type: function
doc:
<comment>Description:</comment>
  Returns a single column from the next row of a result set
    
  
  Returns a single column from the next row of a result set or <info>false</info> if there are no more rows.
  
  PDOStatement::fetchColumn should not be used to retrieve boolean columns, as it is impossible to
  distinguish a value of <info>false</info> from there being no more rows to retrieve. Use PDOStatement::fetch
  instead.

<comment>Param:</comment>
  <info>int</info>  <strong>$column</strong>  0-indexed number of the column you wish to retrieve from the row. If no value is
                supplied, PDOStatement::fetchColumn fetches the first column.

<comment>Return:</comment>
  <info>mixed</info>  PDOStatement::fetchColumn returns a single column from the next row of a result set or
         <info>false</info> if there are no more rows.
         
         There is no way to return another column from the same row if you use
         PDOStatement::fetchColumn to retrieve data.

<comment>See Also:</comment>
   * PDO::query
   * PDOStatement::fetch
   * PDOStatement::fetchAll
   * PDO::prepare
   * PDOStatement::setFetchMode


id: PDOStatement::fetchObject
type: function
doc:
<comment>Description:</comment>
  Fetches the next row and returns it as an object
  
  Fetches the next row and returns it as an object. This function is an alternative to
  PDOStatement::fetch with <info>PDO::FETCH_CLASS</info> or <info>PDO::FETCH_OBJ</info> style.
  
  When an object is fetched, its properties are assigned from respective column values, and
  afterwards its constructor is invoked.

<comment>Param:</comment>
  <info>string|null</info>  <strong>$class</strong>            Name of the created class.
  <info>array</info>        <strong>$constructorArgs</strong>  Elements of this array are passed to the constructor.

<comment>Return:</comment>
  <info>object|false</info>  Returns an instance of the required class with property names that correspond to the
                column names  or <info>false</info> on failure.

<comment>See Also:</comment>
   * PDOStatement::fetch


id: PDOStatement::getAttribute
type: function
doc:
<comment>Description:</comment>
  Retrieve a statement attribute
    
  
  Gets an attribute of the statement. Currently, no generic attributes exist but only driver
  specific: <return>PDO::ATTR_CURSOR_NAME</return> (Firebird and ODBC specific): Get the name of cursor for <return>UPDATE
  ... WHERE CURRENT OF</return>.  Note that driver specific attributes must not be used with other drivers.
  
  <return>PDO::ATTR_CURSOR_NAME</return> (Firebird and ODBC specific): Get the name of cursor for <return>UPDATE ... WHERE
  CURRENT OF</return>.

<comment>Param:</comment>
  <info>int</info>  <strong>$name</strong>  The attribute to query.

<comment>Return:</comment>
  <info>mixed</info>  Returns the attribute value.

<comment>See Also:</comment>
   * PDO::getAttribute
   * PDO::setAttribute
   * PDOStatement::setAttribute


id: PDOStatement::getColumnMeta
type: function
doc:
<comment>Description:</comment>
  Returns metadata for a column in a result set
    
  
  Retrieves the metadata for a 0-indexed column in a result set as an associative array.
  
  Some drivers may not implement PDOStatement::getColumnMeta, as it is optional. However, all PDO
  drivers documented in the manual implement this function.

<comment>Param:</comment>
  <info>int</info>  <strong>$column</strong>  The 0-indexed column in the result set.

<comment>Return:</comment>
  <info>array|false</info>  Returns an associative array containing the following values representing the
               metadata for a single column:
               
               Returns <info>false</info> if the requested column does not exist in the result set, or if no
               result set exists.

<comment>See Also:</comment>
   * PDOStatement::columnCount
   * PDOStatement::rowCount


id: PDOStatement::getIterator
type: function
doc:
<comment>Description:</comment>
  Gets result set iterator
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>Iterator</info>  


id: PDOStatement::nextRowset
type: function
doc:
<comment>Description:</comment>
  Advances to the next rowset in a multi-rowset statement handle
    
  
  Some database servers support stored procedures that return more than one rowset (also known as a
  result set). PDOStatement::nextRowset enables you to access the second and subsequent rowsets
  associated with a PDOStatement object. Each rowset can have a different set of columns from the
  preceding rowset.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * PDOStatement::columnCount
   * PDOStatement::execute
   * PDOStatement::getColumnMeta
   * PDO::query


id: PDOStatement::rowCount
type: function
doc:
<comment>Description:</comment>
  Returns the number of rows affected by the last SQL statement
    
  
  PDOStatement::rowCount returns the number of rows affected by the last DELETE, INSERT, or UPDATE
  statement executed by the corresponding <return>PDOStatement</return> object.
  
  For statements that produce result sets, such as <return>SELECT</return>, the behavior is undefined and can be
  different for each driver. Some databases may return the number of rows produced by that statement
  (e.g. MySQL in buffered mode), but this behaviour is not guaranteed for all databases and should
  not be relied on for portable applications.
  
  This method returns "0" (zero) with the SQLite driver at all times, and with the PostgreSQL driver
  only when setting the <info>PDO::ATTR_CURSOR</info> statement attribute to <info>PDO::CURSOR_SCROLL</info>.

<comment>Return:</comment>
  <info>int</info>  Returns the number of rows.

<comment>See Also:</comment>
   * PDOStatement::columnCount
   * PDOStatement::fetchColumn
   * PDO::query


id: PDOStatement::setAttribute
type: function
doc:
<comment>Description:</comment>
  Set a statement attribute
    
  
  Sets an attribute on the statement. Currently, no generic attributes are set but only driver
  specific: <return>PDO::ATTR_CURSOR_NAME</return> (Firebird and ODBC specific): Set the name of cursor for <return>UPDATE
  ... WHERE CURRENT OF</return>.  Note that driver specific attributes must not be used with other drivers.
  
  <return>PDO::ATTR_CURSOR_NAME</return> (Firebird and ODBC specific): Set the name of cursor for <return>UPDATE ... WHERE
  CURRENT OF</return>.

<comment>Param:</comment>
  <info>int</info>    <strong>$attribute</strong>  The attribute to modify.
  <info>mixed</info>  <strong>$value</strong>      The value to set the <strong>$attribute</strong>, might require a specific type depending on the
                     attribute.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * PDO::getAttribute
   * PDO::setAttribute
   * PDOStatement::getAttribute


id: PDOStatement::setFetchMode
type: function
doc:
<comment>Description:</comment>
  Set the default fetch mode for this statement

<comment>Param:</comment>
  <info>int</info>         <strong>$mode</strong>             The fetch mode must be one of the <return>PDO::FETCH_*</return> constants.
  <info>int</info>         <strong>$colno</strong>            Column number.
  <info>string</info>      <strong>$class</strong>            Class name.
  <info>array|null</info>  <strong>$constructorArgs</strong>  Constructor arguments.
  <info>object</info>      <strong>$object</strong>           Object.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.


id: PGSQL_ASSOC
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_fetch_array()</strong>. Return an associative array of field names and values.


id: PGSQL_BAD_RESPONSE
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_result_status()</strong>. The server's response  was not understood.


id: PGSQL_BOTH
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_fetch_array()</strong>. Return an array of field values that is both numerically indexed (by
  field number) and associated (by field name).


id: PGSQL_COMMAND_OK
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_result_status()</strong>. Successful completion of a  command returning no data.


id: PGSQL_CONNECTION_BAD
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_connection_status()</strong> indicating that the database connection is in an invalid state.


id: PGSQL_CONNECTION_OK
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_connection_status()</strong> indicating that the database connection is in a valid state.


id: PGSQL_CONNECT_ASYNC
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_connect()</strong> to create an asynchronous connection.


id: PGSQL_CONNECT_FORCE_NEW
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_connect()</strong> to force the creation of a new connection, rather than re-using an existing
  identical connection.


id: PGSQL_CONV_FORCE_NULL
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_convert()</strong>. Use SQL <return>NULL</return> in place of an empty <info>string</info>.


id: PGSQL_CONV_IGNORE_DEFAULT
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_convert()</strong>. Ignore default values in the table during conversion.


id: PGSQL_CONV_IGNORE_NOT_NULL
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_convert()</strong>. Ignore conversion of <info>null</info> into SQL <return>NOT NULL</return> columns.


id: PGSQL_COPY_IN
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_result_status()</strong>. Copy In (to server) data  transfer started.


id: PGSQL_COPY_OUT
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_result_status()</strong>. Copy Out (from server) data  transfer started.


id: PGSQL_DIAG_CONTEXT
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_result_error_field()</strong>. An indication of the context in which the error occurred.
  Presently  this includes a call stack traceback of active procedural language  functions and
  internally-generated queries. The trace is one entry  per line, most recent first.


id: PGSQL_DIAG_INTERNAL_POSITION
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_result_error_field()</strong>. This is defined the same as the <info>PG_DIAG_STATEMENT_POSITION</info>
  field, but  it is used when the cursor position refers to an internally generated  command rather
  than the one submitted by the client. The  <info>PG_DIAG_INTERNAL_QUERY</info> field will always appear when
  this  field appears.


id: PGSQL_DIAG_INTERNAL_QUERY
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_result_error_field()</strong>. The text of a failed internally-generated command. This could
  be, for example, a  SQL query issued by a PL/pgSQL function.


id: PGSQL_DIAG_MESSAGE_DETAIL
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_result_error_field()</strong>. Detail: an optional secondary error message carrying more
  detail about the problem. May run to multiple lines.


id: PGSQL_DIAG_MESSAGE_HINT
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_result_error_field()</strong>. Hint: an optional suggestion what to do about the problem. This
  is intended to differ from detail in that it offers advice (potentially inappropriate) rather than
  hard facts. May run to multiple lines.


id: PGSQL_DIAG_MESSAGE_PRIMARY
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_result_error_field()</strong>. The primary human-readable error message (typically one line).
  Always present.


id: PGSQL_DIAG_SEVERITY
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_result_error_field()</strong>. The severity; the field contents are <return>ERROR</return>,  <return>FATAL</return>, or <return>PANIC</return>
  (in an error message), or  <return>WARNING</return>, <return>NOTICE</return>, <return>DEBUG</return>,  <return>INFO</return>, or <return>LOG</return> (in a notice message), or a
  localized  translation of one of these. Always present.


id: PGSQL_DIAG_SEVERITY_NONLOCALIZED
type: constant
doc:
<comment>Description:</comment>
  The severity; the field contents are ERROR, FATAL, or PANIC (in an error message), or WARNING,
  NOTICE, DEBUG, INFO, or LOG (in a notice message). This is identical to the PG_DIAG_SEVERITY field
  except that the contents are never localized. This is present only in versions 9.6 and later / PHP
  7.3.0 and later.


id: PGSQL_DIAG_SOURCE_FILE
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_result_error_field()</strong>. The file name of the PostgreSQL source-code location where the
  error  was reported.


id: PGSQL_DIAG_SOURCE_FUNCTION
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_result_error_field()</strong>. The name of the PostgreSQL source-code function reporting the
  error.


id: PGSQL_DIAG_SOURCE_LINE
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_result_error_field()</strong>. The line number of the PostgreSQL source-code location where
  the  error was reported.


id: PGSQL_DIAG_SQLSTATE
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_result_error_field()</strong>. The SQLSTATE code for the error. The SQLSTATE code identifies
  the type of error  that has occurred; it can be used by front-end applications to perform specific
  operations (such as error handling) in response to a particular database error.  This field is not
  localizable, and is always present.


id: PGSQL_DIAG_STATEMENT_POSITION
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_result_error_field()</strong>. A string containing a decimal integer indicating an error
  cursor position as an index into the original  statement string. The first character has index 1,
  and positions are measured in characters not bytes.


id: PGSQL_DML_ASYNC
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_insert()</strong>, <strong>pg_select()</strong>, <strong>pg_update()</strong> and <strong>pg_delete()</strong>. Execute asynchronous query by
  these functions.


id: PGSQL_DML_ESCAPE
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_insert()</strong>, <strong>pg_select()</strong>, <strong>pg_update()</strong> and <strong>pg_delete()</strong>. Apply escape to all parameters
  instead of calling <strong>pg_convert()</strong> internally. This option omits meta data look up. Query could be as
  fast as <strong>pg_query()</strong> and <strong>pg_send_query()</strong>.


id: PGSQL_DML_EXEC
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_insert()</strong>, <strong>pg_select()</strong>, <strong>pg_update()</strong> and <strong>pg_delete()</strong>. Execute query by these functions.


id: PGSQL_DML_NO_CONV
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_insert()</strong>, <strong>pg_select()</strong>, <strong>pg_update()</strong> and <strong>pg_delete()</strong>. All parameters passed as is.
  Manual escape is required if parameters contain user supplied data. Use <strong>pg_escape_string()</strong> for it.


id: PGSQL_DML_STRING
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_insert()</strong>, <strong>pg_select()</strong>, <strong>pg_update()</strong> and <strong>pg_delete()</strong>. Return executed query string.


id: PGSQL_EMPTY_QUERY
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_result_status()</strong>. The string sent to the server was empty.


id: PGSQL_ERRORS_DEFAULT
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_set_error_verbosity()</strong>. The default mode produces messages that include the above
  plus any detail, hint, or context fields (these may span  multiple lines).


id: PGSQL_ERRORS_TERSE
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_set_error_verbosity()</strong>. Specified that returned messages include severity, primary
  text,  and position only; this will normally fit on a single line.


id: PGSQL_ERRORS_VERBOSE
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_set_error_verbosity()</strong>. The verbose mode includes all available fields.


id: PGSQL_FATAL_ERROR
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_result_status()</strong>. A fatal error  occurred.


id: PGSQL_LIBPQ_VERSION_STR
type: constant
doc:
<comment>Description:</comment>
  Prior to PHP 8.0.0, the long libpq version that includes compiler information. As of PHP 8.0.0,
  the value is identical to <info>PGSQL_LIBPQ_VERSION</info>, and using <info>PGSQL_LIBPQ_VERSION_STR</info> is deprecated.


id: PGSQL_NONFATAL_ERROR
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_result_status()</strong>. A nonfatal error  (a notice or warning) occurred.


id: PGSQL_NOTICE_ALL
type: constant
doc:
<comment>Description:</comment>
  Used by <strong>pg_last_notice()</strong>. Available since PHP 7.1.0.


id: PGSQL_NUM
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_fetch_array()</strong>. Return a numerically indexed array of field numbers and values.


id: PGSQL_POLLING_ACTIVE
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_connect_poll()</strong> to indicate that the connection is currently active.


id: PGSQL_POLLING_FAILED
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_connect_poll()</strong> to indicate that the connection attempt failed.


id: PGSQL_POLLING_OK
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_connect_poll()</strong> to indicate that the connection is ready to be used.


id: PGSQL_POLLING_READING
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_connect_poll()</strong> to indicate that the connection is waiting for the PostgreSQL socket
  to be readable.


id: PGSQL_POLLING_WRITING
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_connect_poll()</strong> to indicate that the connection is waiting for the PostgreSQL socket
  to be writable.


id: PGSQL_SEEK_CUR
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_lo_seek()</strong>. Seek operation is to begin from the current position.


id: PGSQL_SEEK_END
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_lo_seek()</strong>. Seek operation is to begin from the end of the object.


id: PGSQL_SEEK_SET
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_lo_seek()</strong>. Seek operation is to begin from the start of the object.


id: PGSQL_SHOW_CONTEXT_ALWAYS
type: constant
doc:
<comment>Description:</comment>
  To be used with <strong>pg_set_error_context_set_visibility()</strong>, the context's fieds are included in error,
  notice and warning messages. Available as of PHP 8.3.0.


id: PGSQL_SHOW_CONTEXT_ERRORS
type: constant
doc:
<comment>Description:</comment>
  To be used with <strong>pg_set_error_context_set_visibility()</strong>, the context's fieds are included in error
  messages only. This is the default behaviour. Available as of PHP 8.3.0.


id: PGSQL_SHOW_CONTEXT_NEVER
type: constant
doc:
<comment>Description:</comment>
  To be used with <strong>pg_set_error_context_set_visibility()</strong>, the context is never shown. Available as of
  PHP 8.3.0.


id: PGSQL_STATUS_LONG
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_result_status()</strong>.  Indicates that numerical result code is desired.


id: PGSQL_STATUS_STRING
type: constant
doc:
<comment>Description:</comment>
  Passed to <strong>pg_result_status()</strong>.  Indicates that textual result command tag is desired.


id: PGSQL_TRACE_REGRESS_MODE
type: constant
doc:
<comment>Description:</comment>
  To be used with <strong>pg_trace()</strong>, fields such as OIDs are included in the trace's messages. Available as
  of PHP 8.3.0.


id: PGSQL_TRACE_SUPPRESS_TIMESTAMPS
type: constant
doc:
<comment>Description:</comment>
  To be used with <strong>pg_trace()</strong>, the timestamp is not included in the trace's messages. Available as of
  PHP 8.3.0.


id: PGSQL_TRANSACTION_ACTIVE
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_transaction_status()</strong>. A command is in progress on the connection.  A query has been
  sent via the connection and not yet completed.


id: PGSQL_TRANSACTION_IDLE
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_transaction_status()</strong>. Connection is currently idle, not in a transaction.


id: PGSQL_TRANSACTION_INERROR
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_transaction_status()</strong>. The connection is idle, in a failed transaction block.


id: PGSQL_TRANSACTION_INTRANS
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_transaction_status()</strong>. The connection is idle, in a transaction block.


id: PGSQL_TRANSACTION_UNKNOWN
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_transaction_status()</strong>. The connection is bad.


id: PGSQL_TUPLES_OK
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>pg_result_status()</strong>. Successful completion of a command  returning data (such as a
  <return>SELECT</return> or <return>SHOW</return>).


id: PHP_BINDIR
type: constant
doc:
<comment>Description:</comment>
  The value --bindir was set to at configure. On Windows, it is the value --with-prefix was set to
  at configure.


id: PHP_EXTENSION_DIR
type: constant
doc:
<comment>Description:</comment>
  The default directory where to look for dynamically loadable extensions (unless overridden by
  extension_dir). Defaults to <info>PHP_PREFIX</info> (or PHP_PREFIX . "\\ext" on Windows).


id: PHP_EXTRA_VERSION
type: constant
doc:
<comment>Description:</comment>
  The current PHP "extra" version as a string (e.g., '-extra' from version "5.2.7-extra"). Often
  used by distribution vendors to indicate a package version.


id: PHP_FD_SETSIZE
type: constant
doc:
<comment>Description:</comment>
  The maximum number of file descriptors for select system calls. Available as of PHP 7.1.0.


id: PHP_FLOAT_DIG
type: constant
doc:
<comment>Description:</comment>
  Number of decimal digits that can be rounded into a float and back without precision loss.
  Available as of PHP 7.2.0.


id: PHP_FLOAT_EPSILON
type: constant
doc:
<comment>Description:</comment>
  Smallest representable positive number x, so that <return>x + 1.0 != 1.0</return>. Available as of PHP 7.2.0.


id: PHP_FLOAT_MAX
type: constant
doc:
<comment>Description:</comment>
  Largest representable floating point number. Available as of PHP 7.2.0.


id: PHP_FLOAT_MIN
type: constant
doc:
<comment>Description:</comment>
  Smallest representable positive floating point number. If you need the smallest representable
  negative floating point number, use <return>- PHP_FLOAT_MAX</return>. Available as of PHP 7.2.0.


id: PHP_INT_MAX
type: constant
doc:
<comment>Description:</comment>
  The largest integer supported in this build of PHP. Usually int(2147483647) in 32 bit systems and
  int(9223372036854775807) in 64 bit systems.


id: PHP_INT_MIN
type: constant
doc:
<comment>Description:</comment>
  The smallest integer supported in this build of PHP. Usually int(-2147483648) in 32 bit systems
  and int(-9223372036854775808) in 64 bit systems. Usually, PHP_INT_MIN === ~PHP_INT_MAX.


id: PHP_MAJOR_VERSION
type: constant
doc:
<comment>Description:</comment>
  The current PHP "major" version as an integer (e.g., int(5) from version "5.2.7-extra").


id: PHP_MAXPATHLEN
type: constant
doc:
<comment>Description:</comment>
  The maximum length of filenames (including path) supported by this build of PHP.


id: PHP_MINOR_VERSION
type: constant
doc:
<comment>Description:</comment>
  The current PHP "minor" version as an integer (e.g., int(2) from version "5.2.7-extra").


id: PHP_OS_FAMILY
type: constant
doc:
<comment>Description:</comment>
  The operating system family PHP was built for. One of <return>'Windows'</return>, <return>'BSD'</return>, <return>'Darwin'</return>, <return>'Solaris'</return>,
  <return>'Linux'</return> or <return>'Unknown'</return>. Available as of PHP 7.2.0.


id: PHP_OUTPUT_HANDLER_CLEANABLE
type: constant
doc:
<comment>Description:</comment>
  Controls whether an output buffer created by <strong>ob_start()</strong> can be cleaned.


id: PHP_OUTPUT_HANDLER_CONT
type: constant
doc:
<comment>Description:</comment>
  Indicates that the buffer has been flushed, but output buffering will continue.
  
  This is an alias for <info>PHP_OUTPUT_HANDLER_WRITE</info>.


id: PHP_OUTPUT_HANDLER_END
type: constant
doc:
<comment>Description:</comment>
  Indicates that output buffering has ended.
  
  This is an alias for <info>PHP_OUTPUT_HANDLER_FINAL</info>.


id: PHP_OUTPUT_HANDLER_FLUSHABLE
type: constant
doc:
<comment>Description:</comment>
  Controls whether an output buffer created by <strong>ob_start()</strong> can be flushed.


id: PHP_OUTPUT_HANDLER_REMOVABLE
type: constant
doc:
<comment>Description:</comment>
  Controls whether an output buffer created by <strong>ob_start()</strong> can be removed before the end of the
  script.


id: PHP_OUTPUT_HANDLER_STDFLAGS
type: constant
doc:
<comment>Description:</comment>
  The default set of output buffer flags; currently equivalent to <info>PHP_OUTPUT_HANDLER_CLEANABLE</info> |
  <info>PHP_OUTPUT_HANDLER_FLUSHABLE</info> | <info>PHP_OUTPUT_HANDLER_REMOVABLE</info>.


id: PHP_OUTPUT_HANDLER_WRITE
type: constant
doc:
<comment>Description:</comment>
  Indicates that the output buffer is being flushed, and had data to output.


id: PHP_PREFIX
type: constant
doc:
<comment>Description:</comment>
  The value --prefix was set to at configure. On Windows, it is the value --with-prefix was set to
  at configure.


id: PHP_QUERY_RFC1738
type: constant
doc:
<comment>Description:</comment>
  Encoding is performed per RFC 1738 and the <return>application/x-www-form-urlencoded</return> media type, which
  implies that spaces are encoded as plus (<return>+</return>) signs.


id: PHP_QUERY_RFC3986
type: constant
doc:
<comment>Description:</comment>
  Encoding is performed according to RFC 3986, and spaces will be percent encoded (<return>%20</return>).


id: PHP_RELEASE_VERSION
type: constant
doc:
<comment>Description:</comment>
  The current PHP "release" version as an integer (e.g., int(7) from version "5.2.7-extra").


id: PHP_SAPI
type: constant
doc:
<comment>Description:</comment>
  The Server API for this build of PHP. See also <strong>php_sapi_name()</strong>.


id: PHP_SESSION_ACTIVE
type: constant
doc:
<comment>Description:</comment>
  Return value of <strong>session_status()</strong> if sessions are enabled, and a session exists.


id: PHP_SESSION_DISABLED
type: constant
doc:
<comment>Description:</comment>
  Return value of <strong>session_status()</strong> if sessions are disabled.


id: PHP_SESSION_NONE
type: constant
doc:
<comment>Description:</comment>
  Return value of <strong>session_status()</strong> if sessions are enabled, but no session exists.


id: PHP_SHLIB_SUFFIX
type: constant
doc:
<comment>Description:</comment>
  The build-platform's shared library suffix, such as "so" (most Unixes) or "dll" (Windows).


id: PHP_URL_FRAGMENT
type: constant
doc:
<comment>Description:</comment>
  Outputs the fragment (string after the hashmark #) of the URL parsed.


id: PHP_VERSION
type: constant
doc:
<comment>Description:</comment>
  The current PHP version as a string in "major.minor.release[extra]" notation.


id: PHP_VERSION_ID
type: constant
doc:
<comment>Description:</comment>
  The current PHP version as an integer, useful for version comparisons (e.g., int(50207) from
  version "5.2.7-extra").


id: PHP_WINDOWS_EVENT_CTRL_BREAK
type: constant
doc:
<comment>Description:</comment>
  A Windows <return>CTRL+BREAK</return> event. Available as of PHP 7.4.0 (Windows only).


id: PHP_WINDOWS_EVENT_CTRL_C
type: constant
doc:
<comment>Description:</comment>
  A Windows <return>CTRL+C</return> event. Available as of PHP 7.4.0 (Windows only).


id: PHP_WINDOWS_NT_SERVER
type: constant
doc:
<comment>Description:</comment>
  This is a server system (eg. Server 2008/2003/2000), note that if this is a  domain controller its
  reported as <info>PHP_WINDOWS_NT_DOMAIN_CONTROLLER</info>.


id: PHP_WINDOWS_VERSION_BUILD
type: constant
doc:
<comment>Description:</comment>
  The Windows build number (for example, Windows Vista with SP1 applied is build 6001)


id: PHP_WINDOWS_VERSION_MAJOR
type: constant
doc:
<comment>Description:</comment>
  The major version of Windows, this can be either <return>4</return> (NT4/Me/98/95),  <return>5</return> (XP/2003 R2/2003/2000) or <return>6</return>
  (Vista/2008/7/8/8.1).


id: PHP_WINDOWS_VERSION_MINOR
type: constant
doc:
<comment>Description:</comment>
  The minor version of Windows, this can be either <return>0</return> (Vista/2008/2000/NT4/95),  <return>1</return> (XP), <return>2</return> (2003
  R2/2003/XP x64), <return>10</return> (98)  or <return>90</return> (ME).


id: PHP_WINDOWS_VERSION_PLATFORM
type: constant
doc:
<comment>Description:</comment>
  The platform that PHP currently is running on, this value is <return>2</return> on Windows  Vista/XP/2000/NT4,
  Server 2008/2003 and on Windows ME/98/95 this value is <return>1</return>.


id: PHP_WINDOWS_VERSION_PRODUCTTYPE
type: constant
doc:
<comment>Description:</comment>
  This contains the value used to determine the <return>PHP_WINDOWS_NT_*</return> constants. This value may be one of
  the <return>PHP_WINDOWS_NT_*</return> constants  indicating the platform type.


id: PHP_WINDOWS_VERSION_SP_MAJOR
type: constant
doc:
<comment>Description:</comment>
  The major version of the service pack installed, this value is <return>0</return>  if no service pack is installed.
  For example, Windows XP with service pack 3 installed  will make this value <return>3</return>.


id: PHP_WINDOWS_VERSION_SP_MINOR
type: constant
doc:
<comment>Description:</comment>
  The minor version of the service pack installed, this value is <return>0</return>  if no service pack is installed.


id: PHP_WINDOWS_VERSION_SUITEMASK
type: constant
doc:
<comment>Description:</comment>
  The suitemask is a bitmask that can tell if various features of Windows is installed,  see the
  table below for possible bitfield values.


id: PKCS7_BINARY
type: constant
doc:
<comment>Description:</comment>
  Normally the input message is converted to "canonical" format which is effectively using <return>CR</return> and <return>LF</return>
  as end of line: as required by the S/MIME specification.  When this option is present, no
  translation occurs. This is useful when handling binary data which may not be in MIME format.


id: PKCS7_DETACHED
type: constant
doc:
<comment>Description:</comment>
  When signing a message, use cleartext signing with the MIME type <return>"multipart/signed"</return>. This is the
  default if you do not specify any <strong>$flags</strong> to <strong>openssl_pkcs7_sign()</strong>. If you turn this option off, the
  message will be signed using opaque signing, which is more resistant to translation by mail relays
  but cannot be read by mail agents that do not support S/MIME.


id: PKCS7_NOCERTS
type: constant
doc:
<comment>Description:</comment>
  When signing a message the signer's certificate is normally included - with this option it is
  excluded.  This will reduce the size of the signed message but the verifier must have a copy of
  the signers certificate available locally (passed using the <strong>$extracerts</strong> to <strong>openssl_pkcs7_verify()</strong>
  for example).


id: PKCS7_NOCHAIN
type: constant
doc:
<comment>Description:</comment>
  Do not chain verification of signers certificates: that is don't use the certificates in the
  signed message as untrusted CAs.


id: PKCS7_NOINTERN
type: constant
doc:
<comment>Description:</comment>
  When verifying a message, certificates (if any) included in the message are normally searched for
  the signing certificate. With this option only the certificates specified in the <strong>$extracerts</strong>
  parameter of <strong>openssl_pkcs7_verify()</strong> are used.  The supplied certificates can still be used as
  untrusted CAs however.


id: PKCS7_NOOLDMIMETYPE
type: constant
doc:
<comment>Description:</comment>
  Available as of PHP 8.3.0. Sets the content-type to <return>application/pkcs7-mime</return> instead of
  <return>application/x-pkcs7-mime</return> to encrypt a message.


id: PNG_ALL_FILTERS
type: constant
doc:
<comment>Description:</comment>
  A special PNG filter, used by the <strong>imagepng()</strong> function.


id: POSIX_PC_ALLOC_SIZE_MIN
type: constant
doc:
<comment>Description:</comment>
  The minimum number of bytes of storage allocated for any portion of a file. Available as of PHP
  8.3.0.


id: POSIX_PC_ALLOC_SYMLINK_MAX
type: constant
doc:
<comment>Description:</comment>
  The maximum number of symbolic links a given file or directory can have. Available as of PHP
  8.3.0.


id: POSIX_PC_CHOWN_RESTRICTED
type: constant
doc:
<comment>Description:</comment>
  If privileges are required to be allow <strong>chown()</strong> to work. Available as of PHP 8.3.0.


id: POSIX_PC_LINK_MAX
type: constant
doc:
<comment>Description:</comment>
  The maximum number of links a given file or directory can have. Available as of PHP 8.3.0.


id: POSIX_PC_MAX_CANON
type: constant
doc:
<comment>Description:</comment>
  The maximum number of bytes in a terminal canonical input buffer (pathname being then a character
  special file). Available as of PHP 8.3.0.


id: POSIX_PC_MAX_INPUT
type: constant
doc:
<comment>Description:</comment>
  The maximum number of bytes of a terminal input queue (pathname being then a character special
  file). Available as of PHP 8.3.0.


id: POSIX_PC_NAME_MAX
type: constant
doc:
<comment>Description:</comment>
  The maximum number of characters for a file name alone, not its path. Available as of PHP 8.3.0.


id: POSIX_PC_NO_TRUNC
type: constant
doc:
<comment>Description:</comment>
  If a file name (or files under a directory) is longer than <info>POSIX_PC_NAME_MAX</info>. Available as of PHP
  8.3.0.


id: POSIX_PC_PATH_MAX
type: constant
doc:
<comment>Description:</comment>
  The maximum number of characters for a full path name. Available as of PHP 8.3.0.


id: POSIX_PC_PIPE_BUF
type: constant
doc:
<comment>Description:</comment>
  The maximum number of bytes that can be written to a pipe in one operation. Available as of PHP
  8.3.0.


id: POSIX_RLIMIT_AS
type: constant
doc:
<comment>Description:</comment>
  The maximum size of the process's address space in bytes. See also PHP's memory_limit
  configuration directive.


id: POSIX_RLIMIT_CORE
type: constant
doc:
<comment>Description:</comment>
  The maximum size of a core file. If the limit is set to 0, no core file will be generated.


id: POSIX_RLIMIT_CPU
type: constant
doc:
<comment>Description:</comment>
  The maximum amount of CPU time that the process can use, in seconds. When the soft limit is hit, a
  <return>SIGXCPU</return> signal will be sent, which can be caught with <strong>pcntl_signal()</strong>. Depending on the operating
  system, additional <return>SIGXCPU</return> signals may be sent each second until the hard limit is hit, at which
  point an uncatchable <return>SIGKILL</return> signal is sent.
  
  See also <strong>set_time_limit()</strong>.


id: POSIX_RLIMIT_DATA
type: constant
doc:
<comment>Description:</comment>
  The maximum size of the process's data segment, in bytes. It is extremely unlikely that this will
  have any effect on the execution of PHP unless an extension is in use that calls <strong>brk()</strong> or <strong>sbrk()</strong>.


id: POSIX_RLIMIT_KQUEUES
type: constant
doc:
<comment>Description:</comment>
  The maximum number of kqueues this user id is allowed to create (FreeBSD). Available as of PHP
  8.1.0.


id: POSIX_RLIMIT_LOCKS
type: constant
doc:
<comment>Description:</comment>
  The maximum number of locks that the process can create. This is only supported on extremely old
  Linux kernels.


id: POSIX_RLIMIT_MSGQUEUE
type: constant
doc:
<comment>Description:</comment>
  The maximum number of bytes that can be allocated for POSIX message queues. PHP does not ship with
  support for POSIX message queues, so this limit will not have any effect unless you are using an
  extension that implements that support.


id: POSIX_RLIMIT_NICE
type: constant
doc:
<comment>Description:</comment>
  The maximum value to which the process can be reniced to. The value that will be used will be <return>20 -
  limit</return>, as resource limit values cannot be negative.


id: POSIX_RLIMIT_NOFILE
type: constant
doc:
<comment>Description:</comment>
  A value one greater than the maximum file descriptor number that can be opened by this process.


id: POSIX_RLIMIT_NPROC
type: constant
doc:
<comment>Description:</comment>
  The maximum number of processes (and/or threads, on some operating systems) that can be created
  for the real user ID of the process.


id: POSIX_RLIMIT_NPTS
type: constant
doc:
<comment>Description:</comment>
  The maximum number of pseudo-terminals this user id is allowed to create (FreeBSD). Available as
  of PHP 8.1.0.


id: POSIX_RLIMIT_RTPRIO
type: constant
doc:
<comment>Description:</comment>
  The maximum real time priority that can be set via the <strong>sched_setscheduler()</strong> and <strong>sched_setparam()</strong>
  system calls.


id: POSIX_RLIMIT_RTTIME
type: constant
doc:
<comment>Description:</comment>
  The maximum amount of CPU time, in microseconds, that the process can consume without making a
  blocking system call if it is using real time scheduling.


id: POSIX_RLIMIT_SIGPENDING
type: constant
doc:
<comment>Description:</comment>
  The maximum number of signals that can be queued for the real user ID of the process.


id: POSIX_SC_ARG_MAX
type: constant
doc:
<comment>Description:</comment>
  The maximum number of bytes the arguments (and environment variables) can have. Available as of
  PHP 8.3.0.


id: POSIX_SC_NPROCESSORS_CONF
type: constant
doc:
<comment>Description:</comment>
  The number of cpus configured system wise. Available as of PHP 8.3.0.


id: POSIX_SC_NPROCESSORS_ONLN
type: constant
doc:
<comment>Description:</comment>
  The number of cpus currently active system wise. Available as of PHP 8.3.0.


id: POSIX_SC_PAGESIZE
type: constant
doc:
<comment>Description:</comment>
  The number of bytes of the current page. Available as of PHP 8.3.0.


id: PREG_BACKTRACK_LIMIT_ERROR
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>preg_last_error()</strong> if backtrack limit was exhausted.
  
  5.2.0


id: PREG_BAD_UTF8_ERROR
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>preg_last_error()</strong> if the last error was caused by malformed UTF-8 data (only when
  running a regex in UTF-8 mode).
  
  5.2.0


id: PREG_BAD_UTF8_OFFSET_ERROR
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>preg_last_error()</strong> if the offset didn't correspond to the begin of a valid UTF-8 code
  point (only when running a regex in UTF-8 mode).
  
  5.3.0


id: PREG_INTERNAL_ERROR
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>preg_last_error()</strong> if there was an internal PCRE error.
  
  5.2.0


id: PREG_JIT_STACKLIMIT_ERROR
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>preg_last_error()</strong> if the last PCRE function failed due to limited JIT stack space.
  
  7.0.0


id: PREG_NO_ERROR
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>preg_last_error()</strong> if there were no errors.
  
  5.2.0


id: PREG_PATTERN_ORDER
type: constant
doc:
<comment>Description:</comment>
  Orders results so that $matches[0] is an array of full pattern matches, $matches[1] is an array of
  strings matched by the first parenthesized subpattern, and so on. This flag is only used with
  <strong>preg_match_all()</strong>.


id: PREG_RECURSION_LIMIT_ERROR
type: constant
doc:
<comment>Description:</comment>
  Returned by <strong>preg_last_error()</strong> if recursion limit was exhausted.
  
  5.2.0


id: PREG_SET_ORDER
type: constant
doc:
<comment>Description:</comment>
  Orders results so that $matches[0] is an array of first set of matches, $matches[1] is an array of
  second set of matches, and so on. This flag is only used with <strong>preg_match_all()</strong>.


id: PREG_SPLIT_DELIM_CAPTURE
type: constant
doc:
<comment>Description:</comment>
  This flag tells <strong>preg_split()</strong> to capture parenthesized expression in the delimiter pattern as well.


id: PREG_SPLIT_NO_EMPTY
type: constant
doc:
<comment>Description:</comment>
  This flag tells <strong>preg_split()</strong> to return only non-empty pieces.


id: PREG_SPLIT_OFFSET_CAPTURE
type: constant
doc:
<comment>Description:</comment>
  If this flag is set, for every occurring match the appendant string offset will also be returned.
  Note that this changes the return values in an array where every element is an array consisting of
  the matched string at offset 0 and its string offset within subject at offset 1. This flag is only
  used for <strong>preg_split()</strong>.


id: PREG_UNMATCHED_AS_NULL
type: constant
doc:
<comment>Description:</comment>
  This flag tells <strong>preg_match()</strong> and <strong>preg_match_all()</strong> to include unmatched subpatterns in $matches as
  <info>null</info> values. Without this flag, unmatched subpatterns are reported as empty strings, as if they
  were empty matches. Setting this flag allows to distinguish between these two cases.
  
  7.2.0


id: PSFS_ERR_FATAL
type: constant
doc:
<comment>Description:</comment>
  <return>Return Code</return> indicating that the userspace filter encountered an unrecoverable error (i.e. Invalid
  data received).


id: PSFS_FEED_ME
type: constant
doc:
<comment>Description:</comment>
  <return>Return Code</return> indicating that the userspace filter did not return buckets in <strong>$out</strong> (i.e. No data
  available).


id: PSFS_PASS_ON
type: constant
doc:
<comment>Description:</comment>
  <return>Return Code</return> indicating that the userspace filter returned buckets in <strong>$out</strong>.


id: PSpell\Config
type: class
doc:
<comment>Description:</comment>
  A fully opaque class which replaces a <return>pspell config</return> resource as of PHP 8.1.0.


id: PSpell\Dictionary
type: class
doc:
<comment>Description:</comment>
  A fully opaque class which replaces a <return>pspell</return> resource as of PHP 8.1.0.


id: PTHREADS_ALLOW_HEADERS
type: constant
doc:
<comment>Description:</comment>
  Allow new Threads to send headers to standard output (normally prohibited)


id: PTHREADS_INHERIT_ALL
type: constant
doc:
<comment>Description:</comment>
  The default options for all Threads, causes pthreads to copy the environment when new Threads are
  started


id: ParentIterator
type: class
doc:
<comment>Description:</comment>
  This extended <class>FilterIterator</class> allows a recursive iteration using <class>RecursiveIteratorIterator</class> that
  only shows those elements which have children.


id: ParentIterator::__construct
type: function
doc:
<comment>Description:</comment>
  Constructs a ParentIterator
  
  Constructs a <class>ParentIterator</class> on an iterator.
  
  This function is
  currently not documented; only its argument list is available.

<comment>Param:</comment>
  <info>RecursiveIterator</info>  <strong>$iterator</strong>  The iterator being constructed upon.


id: ParentIterator::accept
type: function
doc:
<comment>Description:</comment>
  Determines acceptability
  
  Determines if the current element has children.
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> if the current element is acceptable, otherwise <info>false</info>.

<comment>See Also:</comment>
   * ParentIterator::hasChildren
   * FilterIterator::accept


id: ParentIterator::getChildren
type: function
doc:
<comment>Description:</comment>
  Return the inner iterator's children contained in a ParentIterator
  
  Get the inner iterator's children contained in a ParentIterator.
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>ParentIterator</info>  An <info>object</info>.


id: ParentIterator::hasChildren
type: function
doc:
<comment>Description:</comment>
  Check whether the inner iterator's current element has children
  
  Check whether the inner iterator's current element has children.
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.


id: ParentIterator::next
type: function
doc:
<comment>Description:</comment>
  Move the iterator forward
  
  Moves the iterator forward.
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: ParentIterator::rewind
type: function
doc:
<comment>Description:</comment>
  Rewind the iterator
  
  Rewinds the iterator.
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\ErrorInfo
type: class
doc:
<comment>Description:</comment>
  The class represents detailed error information as supplied by Parle\Parser::errorInfo


id: Parle\INTERNAL_UTF32
type: constant
doc:
<comment>Description:</comment>
  Flag whether the internal UTF-32 support is compiled in. Available since parle 0.7.2.


id: Parle\Lexer
type: class
doc:
<comment>Description:</comment>
  Single state lexer class. Lexemes can be defined on the fly. If the particular lexer instance is
  meant to be used with <class>Parle\Parser</class>, the token IDs need to be taken from there. Otherwise,
  arbitrary token IDs can be supplied. This lexer can give a certain performance advantage over
  <class>Parle\RLexer</class>, if no multiple states are required. Note, that <class>Parle\RParser</class> is not compatible with
  this lexer.


id: Parle\Lexer::advance
type: function
doc:
<comment>Description:</comment>
  Process next lexer rule
  
  Processes the next rule and prepares the resulting token data.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Lexer::build
type: function
doc:
<comment>Description:</comment>
  Finalize the lexer rule set
  
  Rules, previously added with Parle\Lexer::push are finalized. This method call has to be done
  after all the necessary rules was pushed. The rule set becomes read only. The lexing can begin.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Lexer::callout
type: function
doc:
<comment>Description:</comment>
  Define token callback
  
  Define a callback to be invoked once lexer encounters a particular token.

<comment>Param:</comment>
  <info>int</info>       <strong>$id</strong>        Token id.
  <info>callable</info>  <strong>$callback</strong>  Callable to be invoked. The callable doesn't receive any arguments and its
                       return value is ignored.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Lexer::consume
type: function
doc:
<comment>Description:</comment>
  Pass the data for processing
  
  Consume the data for lexing.

<comment>Param:</comment>
  <info>string</info>  <strong>$data</strong>  Data to be lexed.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Lexer::dump
type: function
doc:
<comment>Description:</comment>
  Dump the state machine
  
  Dump the current state machine to stdout.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Lexer::getToken
type: function
doc:
<comment>Description:</comment>
  Retrieve the current token
  
  Retrieve the current token.

<comment>Return:</comment>
  <info>Parle\Token</info>  Returns an instance of <class>Parle\Token</class>.


id: Parle\Lexer::insertMacro
type: function
doc:
<comment>Description:</comment>
  Insert regex macro
  
  Insert a regex macro, that can be later used as a shortcut and included in other regular
  expressions.

<comment>Param:</comment>
  <info>string</info>  <strong>$name</strong>   Name of the macros.
  <info>string</info>  <strong>$regex</strong>  Regular expression.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Lexer::push
type: function
doc:
<comment>Description:</comment>
  Add a lexer rule
  
  Push a pattern for lexeme recognition.

<comment>Param:</comment>
  <info>string</info>  <strong>$regex</strong>  Regular expression used for token matching.
  <info>int</info>     <strong>$id</strong>     Token id. If the lexer instance is meant to be used standalone, this can be an
                  arbitrary number. If the lexer instance is going to be passed to the parser, it
                  has to be an id returned by Parle\Parser::tokenid.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Lexer::reset
type: function
doc:
<comment>Description:</comment>
  Reset lexer
  
  Reset lexing optionally supplying the desired offset.

<comment>Param:</comment>
  <info>int</info>  <strong>$pos</strong>  Reset position.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Parser
type: class
doc:
<comment>Description:</comment>
  Parser class. Rules can be defined on the fly. Once finalized, a <class>Parle\Lexer</class> instance is required
  to deliver the token stream.


id: Parle\Parser::advance
type: function
doc:
<comment>Description:</comment>
  Process next parser rule
  
  Process next parser rule.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Parser::build
type: function
doc:
<comment>Description:</comment>
  Finalize the grammar rules
  
  Any tokens and grammar rules previously added are finalized. The rule set becomes readonly and the
  parser is ready to start.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Parser::consume
type: function
doc:
<comment>Description:</comment>
  Consume the data for processing
  
  Consume the data for parsing.

<comment>Param:</comment>
  <info>string</info>       <strong>$data</strong>   Data to be parsed.
  <info>Parle\Lexer</info>  <strong>$lexer</strong>  A lexer object containing the lexing rules prepared for the particular
                       grammar.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Parser::dump
type: function
doc:
<comment>Description:</comment>
  Dump the grammar
  
  Dump the current grammar to stdout.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Parser::errorInfo
type: function
doc:
<comment>Description:</comment>
  Retrieve the error information
  
  Retrieve the error information in case Parle\Parser::action returned the error action.

<comment>Return:</comment>
  <info>Parle\ErrorInfo</info>  Returns an instance of <class>Parle\ErrorInfo</class>.


id: Parle\Parser::left
type: function
doc:
<comment>Description:</comment>
  Declare a token with left-associativity
  
  Declare a terminal with left associativity.

<comment>Param:</comment>
  <info>string</info>  <strong>$tok</strong>  Token name.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Parser::nonassoc
type: function
doc:
<comment>Description:</comment>
  Declare a token with no associativity
  
  Declare a terminal, that cannot appear more than once in the row.

<comment>Param:</comment>
  <info>string</info>  <strong>$tok</strong>  Token name.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Parser::precedence
type: function
doc:
<comment>Description:</comment>
  Declare a precedence rule
  
  Declares a precedence rule for a fictitious terminal symbol. This rule can be later used in the
  specific grammar rules.

<comment>Param:</comment>
  <info>string</info>  <strong>$tok</strong>  Token name.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Parser::push
type: function
doc:
<comment>Description:</comment>
  Add a grammar rule
  
  Push a grammar rule. The production id returned can be used later in the parsing process to
  identify the rule matched.

<comment>Param:</comment>
  <info>string</info>  <strong>$name</strong>  Rule name.
  <info>string</info>  <strong>$rule</strong>  The rule to be added. The syntax is Bison compatible.

<comment>Return:</comment>
  <info>int</info>  Returns <info>int</info> representing the rule index.


id: Parle\Parser::reset
type: function
doc:
<comment>Description:</comment>
  Reset parser state
  
  Reset parser state using the given token id.

<comment>Param:</comment>
  <info>int</info>  <strong>$tokenId</strong>  Token id.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Parser::right
type: function
doc:
<comment>Description:</comment>
  Declare a token with right-associativity
  
  Declare a terminal with right associativity.

<comment>Param:</comment>
  <info>string</info>  <strong>$tok</strong>  Token name.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Parser::sigil
type: function
doc:
<comment>Description:</comment>
  Retrieve a matching part of a rule
  
  Retrieve a part of the match by a rule. This method is equivalent to the pseudo variable
  functionality in Bison.

<comment>Param:</comment>
  <info>int</info>  <strong>$idx</strong>  Match index, zero based.

<comment>Return:</comment>
  <info>string</info>  Returns a <info>string</info> with the matched part.


id: Parle\Parser::sigilCount
type: function
doc:
<comment>Description:</comment>
  Number of elements in matched rule
  
  Get number of elements in the matched rule.

<comment>Return:</comment>
  <info>int</info>  Returns <info>int</info>


id: Parle\Parser::sigilName
type: function
doc:
<comment>Description:</comment>
  Retrieve a rule or token name
  
  Retrieve a partial rule name or token name corresponding to the sigil index.

<comment>Param:</comment>
  <info>int</info>  <strong>$idx</strong>  Match index, zero based.

<comment>Return:</comment>
  <info>string</info>  Returns a <info>string</info> with the matched part.


id: Parle\Parser::token
type: function
doc:
<comment>Description:</comment>
  Declare a token
  
  Declare a terminal to be used in the grammar.

<comment>Param:</comment>
  <info>string</info>  <strong>$tok</strong>  Token name.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Parser::tokenId
type: function
doc:
<comment>Description:</comment>
  Get token id
  
  Retrieve the id of the named token.

<comment>Param:</comment>
  <info>string</info>  <strong>$tok</strong>  Name of the token as used in Parle\Parser::token.

<comment>Return:</comment>
  <info>int</info>  Returns <info>int</info> representing the token id.


id: Parle\Parser::trace
type: function
doc:
<comment>Description:</comment>
  Trace the parser operation
  
  Retrieve the current parser operation description. This can be especially useful for studying the
  parser and to optimize the grammar.

<comment>Return:</comment>
  <info>string</info>  Returns a <info>string</info> with the trace information.


id: Parle\Parser::validate
type: function
doc:
<comment>Description:</comment>
  Validate input
  
  Validate an input string. The string is parsed internally, thus this method is useful for the
  quick input validation.

<comment>Param:</comment>
  <info>string</info>       <strong>$data</strong>   String to be validated.
  <info>Parle\Lexer</info>  <strong>$lexer</strong>  A lexer object containing the lexing rules prepared for the particular
                       grammar.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>bool</info> witnessing whether the input chimes or not with the defined rules.


id: Parle\RLexer
type: class
doc:
<comment>Description:</comment>
  Multistate lexer class. Lexemes can be defined on the fly. If the particular lexer instance is
  meant to be used with <class>Parle\RParser</class>, the token IDs need to be taken from there. Otherwise,
  arbitrary token IDs can be supplied. Note, that <class>Parle\Parser</class> is not compatible with this lexer.


id: Parle\RLexer::build
type: function
doc:
<comment>Description:</comment>
  Finalize the lexer rule set
  
  Rules, previously added with Parle\RLexer::push are finalized. This method call has to be done
  after all the necessary rules was pushed. The rule set becomes read only. The lexing can begin.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\RLexer::getToken
type: function
doc:
<comment>Description:</comment>
  Retrieve the current token
  
  Retrive the current token.

<comment>Return:</comment>
  <info>Parle\Token</info>  Returns an instance of <class>Parle\Token</class>.


id: Parle\RLexer::push
type: function
doc:
<comment>Description:</comment>
  Add a lexer rule
  
  Push a pattern for lexeme recognition.
  
  A 'start state' and 'exit state' can be specified by using a suitable signature.

<comment>Param:</comment>
  <info>string</info>  <strong>$regex</strong>     Regular expression used for token matching.
  <info>int</info>     <strong>$id</strong>        Token id. If the lexer instance is meant to be used standalone, this can be an
                     arbitrary number. If the lexer instance is going to be passed to the parser, it
                     has to be an id returned by Parle\RParser::tokenid.
  <info>string</info>  <strong>$state</strong>     State name. If '*' is used as start state, then the rule is applied to all
                     lexer states.
  <info>string</info>  <strong>$newState</strong>  New state name, after the rule was applied.
                     
                     If '.' is specified as the exit state, then the lexer state is unchanged when
                     that rule matches. An exit state with '&gt;' before the name means push. Use
                     the signature without id for either continuation or to start matching, when a
                     continuation or recursion is required.
                     
                     If '\<' is specified as exit state, it means pop. In that case, the signature containing the id can be used to identify the match. Note that even in the case an id is specified, the rule will finish first when all the previous pushes popped.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\RLexer::pushState
type: function
doc:
<comment>Description:</comment>
  Push a new start state
  
  This lexer type can have more than one state machine. This allows you to lex different tokens
  depending on context, thus allowing simple parsing to take place. Once a state pushed, it can be
  used with a suitable Parle\RLexer::push signature variant.

<comment>Param:</comment>
  <info>string</info>  <strong>$state</strong>  Name of the state.

<comment>Return:</comment>
  <info>int</info>  


id: Parle\RParser
type: class
doc:
<comment>Description:</comment>
  Parser class. Rules can be defined on the fly. Once finalized, a <class>Parle\RLexer</class> instance is required
  to deliver the token stream.


id: Parle\RParser::advance
type: function
doc:
<comment>Description:</comment>
  Process next parser rule
  
  Prosess next parser rule.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\RParser::consume
type: function
doc:
<comment>Description:</comment>
  Consume the data for processing
  
  Consume the data for parsing.

<comment>Param:</comment>
  <info>string</info>  <strong>$data</strong>   Data to be parsed.
  <info></info>        <strong>$lexer</strong>  A lexer object containing the lexing rules prepared for the particular grammar.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\RParser::errorInfo
type: function
doc:
<comment>Description:</comment>
  Retrieve the error information
  
  Retrieve the error information in case Parle\RParser::action returned the error action.

<comment>Return:</comment>
  <info>Parle\ErrorInfo</info>  Returns an instance of <class>Parle\ErrorInfo</class>.


id: Parle\RParser::precedence
type: function
doc:
<comment>Description:</comment>
  Declare a precedence rule
  
  Declares a precedence rule for a fictious terminal symbol. This rule can be later used in the
  specific grammar rules.

<comment>Param:</comment>
  <info>string</info>  <strong>$tok</strong>  Token name.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\RParser::tokenId
type: function
doc:
<comment>Description:</comment>
  Get token id
  
  Retrieve the id of the named token.

<comment>Param:</comment>
  <info>string</info>  <strong>$tok</strong>  Name of the token as used in Parle\RParser::token.

<comment>Return:</comment>
  <info>int</info>  Returns <info>int</info> representing the token id.


id: Parle\RParser::trace
type: function
doc:
<comment>Description:</comment>
  Trace the parser operation
  
  Retrieve the current parser operation description. This can be especially useful to study the
  parser and to optimize the grammar.

<comment>Return:</comment>
  <info>string</info>  Returns a <info>string</info> with the trace information.


id: Parle\RParser::validate
type: function
doc:
<comment>Description:</comment>
  Validate input
  
  Validate an input string. The string is parsed internally, thus this method is useful for the
  quick input validation.

<comment>Param:</comment>
  <info>string</info>        <strong>$data</strong>   String to be validated.
  <info>Parle\RLexer</info>  <strong>$lexer</strong>  A lexer object containing the lexing rules prepared for the particular
                        grammar.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>bool</info> whitnessing whether the input chimes or not with the defined rules.


id: Parle\Stack
type: class
doc:
<comment>Description:</comment>
  <class>Parle\Stack</class> is a LIFO stack. The elements are inserted and removed only from one end.


id: Parle\Stack::pop
type: function
doc:
<comment>Description:</comment>
  Pop an item from the stack

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Stack::push
type: function
doc:
<comment>Description:</comment>
  Push an item into the stack

<comment>Param:</comment>
  <info>mixed</info>  <strong>$item</strong>  Variable to be pushed.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Parle\Token
type: class
doc:
<comment>Description:</comment>
  This class represents a token. Lexer returns instances of this class.


id: PgSql\Connection
type: class
doc:
<comment>Description:</comment>
  A fully opaque class which replaces a <return>pgsql link</return> resource as of PHP 8.1.0.


id: PgSql\Lob
type: class
doc:
<comment>Description:</comment>
  A fully opaque class which replaces a <return>pgsql large object</return> resource as of PHP 8.1.0.


id: PgSql\Result
type: class
doc:
<comment>Description:</comment>
  A fully opaque class which replaces a <return>pgsql result</return> resource as of PHP 8.1.0.


id: Phar
type: class
doc:
<comment>Description:</comment>
  The Phar class provides a high-level interface to accessing and creating phar archives.


id: Phar::COMPRESSED
type: constant
doc:
<comment>Description:</comment>
  0x0000F000
  
  bitmask that can be used with file flags to determine if any compression is present


id: Phar::OPENSSL
type: constant
doc:
<comment>Description:</comment>
  signature with OpenSSL public/private key pair.  This is a true, asymmetric key signature.


id: Phar::PHP
type: constant
doc:
<comment>Description:</comment>
  used to instruct the mimeoverrides parameter of <strong>Phar::webPhar()</strong> that the extension should be
  parsed as a PHP file


id: Phar::PHPS
type: constant
doc:
<comment>Description:</comment>
  used to instruct the mimeoverrides parameter of <strong>Phar::webPhar()</strong> that the extension should be
  parsed as a PHP source file through <strong>highlight_file()</strong>


id: Phar::__construct
type: function
doc:
<comment>Description:</comment>
  Construct a Phar archive object

<comment>Param:</comment>
  <info>string</info>       <strong>$filename</strong>  Path to an existing Phar archive or to-be-created archive. The file name's
                          extension must contain .phar.
  <info>int</info>          <strong>$flags</strong>     Flags to pass to parent class <class>RecursiveDirectoryIterator</class>.
  <info>string|null</info>  <strong>$alias</strong>     Alias with which this Phar archive should be referred to in calls to
                          stream functionality.


id: Phar::addEmptyDir
type: function
doc:
<comment>Description:</comment>
  Add an empty directory to the phar archive
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  With this method, an empty directory is created with path <return>dirname</return>. This method is similar to
  <strong>ZipArchive::addEmptyDir()</strong>.

<comment>Param:</comment>
  <info>string</info>  <strong>$directory</strong>  The name of the empty directory to create in the phar archive

<comment>Return:</comment>
  <info>void</info>  no return value, exception is thrown on failure.

<comment>See Also:</comment>
   * <strong>PharData::addEmptyDir()</strong>
   * <strong>Phar::addFile()</strong>
   * <strong>Phar::addFromString()</strong>


id: Phar::addFile
type: function
doc:
<comment>Description:</comment>
  Add a file from the filesystem to the phar archive
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  With this method, any file or URL can be added to the phar archive.  If the optional second
  parameter <strong>$localName</strong> is a <info>string</info>, the file will be stored in the archive with that name, otherwise
  the <return>file</return> parameter is used as the path to store within the archive.  URLs must have a localname or
  an exception is thrown. This method is similar to <strong>ZipArchive::addFile()</strong>.

<comment>Param:</comment>
  <info>string</info>       <strong>$filename</strong>   Full or relative path to a file on disk to be added to the phar archive.
  <info>string|null</info>  <strong>$localName</strong>  Path that the file will be stored in the archive.

<comment>Return:</comment>
  <info>void</info>  no return value, exception is thrown on failure.

<comment>See Also:</comment>
   * <strong>Phar::offsetSet()</strong>
   * <strong>PharData::addFile()</strong>
   * <strong>Phar::addFromString()</strong>
   * <strong>Phar::addEmptyDir()</strong>


id: Phar::addFromString
type: function
doc:
<comment>Description:</comment>
  Add a file from a string to the phar archive
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  With this method, any string can be added to the phar archive. The file will be stored in the
  archive with <return>localname</return> as its path.  This method is similar to <strong>ZipArchive::addFromString()</strong>.

<comment>Param:</comment>
  <info>string</info>  <strong>$localName</strong>  Path that the file will be stored in the archive.
  <info>string</info>  <strong>$contents</strong>   The file contents to store

<comment>Return:</comment>
  <info>void</info>  no return value, exception is thrown on failure.

<comment>See Also:</comment>
   * <strong>Phar::offsetSet()</strong>
   * <strong>PharData::addFromString()</strong>
   * <strong>Phar::addFile()</strong>
   * <strong>Phar::addEmptyDir()</strong>


id: Phar::apiVersion
type: function
doc:
<comment>Description:</comment>
  Returns the api version
  
  Return the API version of the phar file format that will be used when creating phars.  The Phar
  extension supports reading API version 1.0.0 or newer.  API version 1.1.0 is required for SHA-256
  and SHA-512 hash, and API version 1.1.1 is required to store empty directories.

<comment>Return:</comment>
  <info>string</info>  The API version string as in <return>"1.0.0"</return>.


id: Phar::buildFromDirectory
type: function
doc:
<comment>Description:</comment>
  Construct a phar archive from the files within a directory
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  Populate a phar archive from directory contents.  The optional second parameter is a regular
  expression (pcre) that is used to exclude files. Any filename that matches the regular expression
  will be included, all others will be excluded.  For more fine-grained control, use
  <strong>Phar::buildFromIterator()</strong>.

<comment>Param:</comment>
  <info>string</info>  <strong>$directory</strong>  The full or relative path to the directory that contains all files to add to
                      the archive.
  <info>string</info>  <strong>$pattern</strong>    An optional pcre regular expression that is used to filter the list of files.
                      Only file paths matching the regular expression will be included in the
                      archive.

<comment>Return:</comment>
  <info>array</info>  <strong>Phar::buildFromDirectory()</strong> returns an associative array mapping internal path of file to
         the full path of the file on the filesystem.

<comment>See Also:</comment>
   * <strong>Phar::buildFromIterator()</strong>


id: Phar::buildFromIterator
type: function
doc:
<comment>Description:</comment>
  Construct a phar archive from an iterator
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  Populate a phar archive from an iterator.  Two styles of iterators are supported, iterators that
  map the filename within the phar to the name of a file on disk, and iterators like
  DirectoryIterator that return SplFileInfo objects.  For iterators that return SplFileInfo objects,
  the second parameter is required.

<comment>Param:</comment>
  <info>Traversable</info>  <strong>$iterator</strong>       Any iterator that either associatively maps phar file to location or
                               returns SplFileInfo objects
  <info>string|null</info>  <strong>$baseDirectory</strong>  For iterators that return SplFileInfo objects, the portion of each
                               file's full path to remove when adding to the phar archive

<comment>Return:</comment>
  <info>array</info>  <strong>Phar::buildFromIterator()</strong> returns an associative array mapping internal path of file to the
         full path of the file on the filesystem.

<comment>See Also:</comment>
   * <strong>Phar::buildFromDirectory()</strong>


id: Phar::canCompress
type: function
doc:
<comment>Description:</comment>
  Returns whether phar extension supports compression using either zlib or bzip2
  
  This should be used to test whether compression is possible prior to loading a phar archive
  containing compressed files.

<comment>Param:</comment>
  <info>int</info>  <strong>$compression</strong>  Either <return>Phar::GZ</return> or <return>Phar::BZ2</return> can be used to test whether compression is
                     possible with a specific compression algorithm (zlib or bzip2).

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> if compression/decompression is available, <info>false</info> if not.

<comment>See Also:</comment>
   * <strong>PharFileInfo::getCompressedSize()</strong>
   * <strong>PharFileInfo::isCompressed()</strong>
   * <strong>PharFileInfo::compress()</strong>
   * <strong>PharFileInfo::decompress()</strong>
   * <strong>Phar::isCompressed()</strong>
   * <strong>Phar::compressFiles()</strong>
   * <strong>Phar::decompressFiles()</strong>
   * <strong>Phar::getSupportedCompression()</strong>
   * <strong>Phar::convertToExecutable()</strong>
   * <strong>Phar::convertToData()</strong>


id: Phar::canWrite
type: function
doc:
<comment>Description:</comment>
  Returns whether phar extension supports writing and creating phars
  
  This static method determines whether write access has been disabled in the system php.ini via the
  phar.readonly ini variable.

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> if write access is enabled, <info>false</info> if it is disabled.

<comment>See Also:</comment>
   * phar.readonly
   * <strong>Phar::isWritable()</strong>


id: Phar::compress
type: function
doc:
<comment>Description:</comment>
  Compresses the entire Phar archive using Gzip or Bzip2 compression
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  For tar-based and phar-based phar archives, this method compresses the entire archive using gzip
  compression or bzip2 compression.  The resulting file can be processed with the gunzip
  command/bunzip command, or accessed directly and transparently with the Phar extension.
  
  For Zip-based phar archives, this method fails with an exception. The zlib extension must be
  enabled to compress with gzip compression, the bzip2 extension must be enabled in order to
  compress with bzip2 compression. As with all functionality that modifies the contents of a phar,
  the phar.readonly INI variable must be off in order to succeed.
  
  In addition, this method automatically renames the archive, appending <return>.gz</return>, <return>.bz2</return> or removing the
  extension if passed <return>Phar::NONE</return> to remove compression.  Alternatively, a file extension may be
  specified with the second parameter.

<comment>Param:</comment>
  <info>int</info>          <strong>$compression</strong>  Compression must be one of <return>Phar::GZ</return>, <return>Phar::BZ2</return> to add compression, or
                             <return>Phar::NONE</return> to remove compression.
  <info>string|null</info>  <strong>$extension</strong>    By default, the extension is <return>.phar.gz</return> or <return>.phar.bz2</return> for compressing phar
                             archives, and <return>.phar.tar.gz</return> or <return>.phar.tar.bz2</return> for compressing tar
                             archives.  For decompressing, the default file extensions are <return>.phar</return> and
                             <return>.phar.tar</return>.

<comment>Return:</comment>
  <info>Phar|null</info>  Returns a <class>Phar</class> object, or <info>null</info> on failure.

<comment>See Also:</comment>
   * <strong>PharFileInfo::getCompressedSize()</strong>
   * <strong>PharFileInfo::isCompressed()</strong>
   * <strong>PharFileInfo::compress()</strong>
   * <strong>PharFileInfo::decompress()</strong>
   * <strong>PharData::compress()</strong>
   * <strong>Phar::canCompress()</strong>
   * <strong>Phar::isCompressed()</strong>
   * <strong>Phar::decompress()</strong>
   * <strong>Phar::getSupportedCompression()</strong>
   * <strong>Phar::compressFiles()</strong>
   * <strong>Phar::decompressFiles()</strong>


id: Phar::compressFiles
type: function
doc:
<comment>Description:</comment>
  Compresses all files in the current Phar archive
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  For tar-based phar archives, this method throws a <class>BadMethodCallException</class>, as compression of
  individual files within a tar archive is not supported by the file format.  Use <strong>Phar::compress()</strong>
  to compress an entire tar-based phar archive.
  
  For Zip-based and phar-based phar archives, this method compresses all files in the Phar archive
  using the specified compression. The zlib  or bzip2 extensions must be enabled to take advantage
  of this feature.  In addition, if any files are already compressed using bzip2/zlib compression,
  the respective extension must be enabled in order to decompress the files prior to re-compressing.
  As with all functionality that modifies the contents of a phar, the phar.readonly INI variable
  must be off in order to succeed.

<comment>Param:</comment>
  <info>int</info>  <strong>$compression</strong>  Compression must be one of <return>Phar::GZ</return>, <return>Phar::BZ2</return> to add compression, or
                     <return>Phar::NONE</return> to remove compression.

<comment>Return:</comment>
  <info>void</info>  No value is returned.

<comment>See Also:</comment>
   * <strong>PharFileInfo::getCompressedSize()</strong>
   * <strong>PharFileInfo::isCompressed()</strong>
   * <strong>PharFileInfo::compress()</strong>
   * <strong>PharFileInfo::decompress()</strong>
   * <strong>Phar::canCompress()</strong>
   * <strong>Phar::isCompressed()</strong>
   * <strong>Phar::decompressFiles()</strong>
   * <strong>Phar::getSupportedCompression()</strong>
   * <strong>Phar::compress()</strong>
   * <strong>Phar::decompress()</strong>


id: Phar::convertToData
type: function
doc:
<comment>Description:</comment>
  Convert a phar archive to a non-executable tar or zip file
  
  This method is used to convert an executable phar archive to either a tar or zip file.  To make
  the tar or zip non-executable, the phar stub and phar alias files are removed from the newly
  created archive.
  
  If no changes are specified, this method throws a <class>BadMethodCallException</class> if the archive is in phar
  file format.  For archives in tar or zip file format, this method converts the archive to a
  non-executable archive.
  
  If successful, the method creates a new archive on disk and returns a <class>PharData</class> object.  The old
  archive is not removed from disk, and should be done manually after the process has finished.

<comment>Param:</comment>
  <info>int|null</info>     <strong>$format</strong>       This should be one of <return>Phar::TAR</return> or <return>Phar::ZIP</return>.  If set to <info>null</info>, the
                             existing file format will be preserved.
  <info>int|null</info>     <strong>$compression</strong>  This should be one of <return>Phar::NONE</return> for no whole-archive compression,
                             <return>Phar::GZ</return> for zlib-based compression, and <return>Phar::BZ2</return> for bzip-based
                             compression.
  <info>string|null</info>  <strong>$extension</strong>    This parameter is used to override the default file extension for a
                             converted archive.  Note that <return>.phar</return> cannot be used anywhere in the
                             filename for a non-executable tar or zip archive.
                             
                             If converting to a tar-based phar archive, the default extensions are
                             <return>.tar</return>, <return>.tar.gz</return>, and <return>.tar.bz2</return> depending on specified compression. For
                             zip-based archives, the default extension is <return>.zip</return>.

<comment>Return:</comment>
  <info>PharData|null</info>  The method returns a <class>PharData</class> object on success, or <info>null</info> on failure.

<comment>See Also:</comment>
   * <strong>Phar::convertToExecutable()</strong>
   * <strong>PharData::convertToExecutable()</strong>
   * <strong>PharData::convertToData()</strong>


id: Phar::convertToExecutable
type: function
doc:
<comment>Description:</comment>
  Convert a phar archive to another executable phar archive file format
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  This method is used to convert a phar archive to another file format.  For instance, it can be
  used to create a tar-based executable phar archive from a zip-based executable phar archive, or
  from an executable phar archive in the phar file format.  In addition, it can be used to apply
  whole-archive compression to a tar or phar-based archive.
  
  If no changes are specified, this method throws a <class>BadMethodCallException</class>.
  
  If successful, the method creates a new archive on disk and returns a <class>Phar</class> object.  The old
  archive is not removed from disk, and should be done manually after the process has finished.

<comment>Param:</comment>
  <info>int|null</info>     <strong>$format</strong>       This should be one of <return>Phar::PHAR</return>, <return>Phar::TAR</return>, or <return>Phar::ZIP</return>.  If set to
                             <info>null</info>, the existing file format will be preserved.
  <info>int|null</info>     <strong>$compression</strong>  This should be one of <return>Phar::NONE</return> for no whole-archive compression,
                             <return>Phar::GZ</return> for zlib-based compression, and <return>Phar::BZ2</return> for bzip-based
                             compression.
  <info>string|null</info>  <strong>$extension</strong>    This parameter is used to override the default file extension for a
                             converted archive.  Note that all zip- and tar-based phar archives must
                             contain <return>.phar</return> in their file extension in order to be processed as a
                             phar archive.
                             
                             If converting to a phar-based archive, the default extensions are
                             <return>.phar</return>, <return>.phar.gz</return>, or <return>.phar.bz2</return> depending on the specified compression.
                             For tar-based phar archives, the default extensions are <return>.phar.tar</return>,
                             <return>.phar.tar.gz</return>, and <return>.phar.tar.bz2</return>.  For zip-based phar archives, the
                             default extension is <return>.phar.zip</return>.

<comment>Return:</comment>
  <info>Phar|null</info>  The method returns a <class>Phar</class> object on success, or <info>null</info> on failure.

<comment>See Also:</comment>
   * <strong>Phar::convertToData()</strong>
   * <strong>PharData::convertToExecutable()</strong>
   * <strong>PharData::convertToData()</strong>


id: Phar::copy
type: function
doc:
<comment>Description:</comment>
  Copy a file internal to the phar archive to another new file within the phar
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  Copy a file internal to the phar archive to another new file within the phar. This is an
  object-oriented alternative to using <strong>copy()</strong> with the phar stream wrapper.

<comment>Param:</comment>
  <info>string</info>  <strong>$from</strong>  
  <info>string</info>  <strong>$to</strong>    

<comment>Return:</comment>
  <info>bool</info>  returns <info>true</info> on success, but it is safer to encase method call in a try/catch block and
        assume success if no exception is thrown.


id: Phar::count
type: function
doc:
<comment>Description:</comment>
  Returns the number of entries (files) in the Phar archive

<comment>Param:</comment>
  <info>int</info>  <strong>$mode</strong>  <strong>$mode</strong> is an integer value specifying the counting mode to be used. By default, it is
              set to <info>COUNT_NORMAL</info>, which counts only the number of items in the archive that have
              not been deleted or hidden. When set to <info>COUNT_RECURSIVE</info>, it counts all items in the
              archive, including those that have been deleted or hidden.

<comment>Return:</comment>
  <info>int</info>  The number of files contained within this phar, or <return>0</return> (the number zero) if none.


id: Phar::createDefaultStub
type: function
doc:
<comment>Description:</comment>
  Create a phar-file format specific stub
  
  This method is intended for creation of phar-file format-specific stubs, and is not intended for
  use with tar- or zip-based phar archives.
  
  Phar archives contain a bootstrap loader, or <return>stub</return> written in PHP that is executed when the archive
  is executed in PHP either via include:  ]]> or by simple execution:
  
  This method provides a simple and easy method to create a stub that will run a startup file from
  the phar archive.  In addition, different files can be specified for running the phar archive from
  the command line versus through a web server.  The loader stub also calls
  <strong>Phar::interceptFileFuncs()</strong> to allow easy bundling of a PHP application that accesses the file
  system.  If the phar extension is not present, the loader stub will extract the phar archive to a
  temporary directory and then operate on the files.  A shutdown function erases the temporary files
  on exit.

<comment>Param:</comment>
  <info>string|null</info>  <strong>$index</strong>     Relative path within the phar archive to run if accessed on the
                          command-line
  <info>string|null</info>  <strong>$webIndex</strong>  Relative path within the phar archive to run if accessed through a web
                          browser

<comment>Return:</comment>
  <info>string</info>  Returns a string containing the contents of a customized bootstrap loader (stub) that
          allows the created Phar archive to work with or without the Phar extension enabled.

<comment>See Also:</comment>
   * <strong>Phar::setStub()</strong>
   * <strong>Phar::getStub()</strong>


id: Phar::decompress
type: function
doc:
<comment>Description:</comment>
  Decompresses the entire Phar archive
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  For tar-based and phar-based phar archives, this method decompresses the entire archive.
  
  For Zip-based phar archives, this method fails with an exception. The zlib extension must be
  enabled to decompress an archive compressed with gzip compression, and the bzip2 extension must be
  enabled in order to decompress an archive compressed with bzip2 compression. As with all
  functionality that modifies the contents of a phar, the phar.readonly INI variable must be off in
  order to succeed.
  
  In addition, this method automatically changes the file extension of the archive, <return>.phar</return> by default
  for phar archives, or <return>.phar.tar</return> for tar-based phar archives. Alternatively, a file extension may
  be specified with the second parameter.

<comment>Param:</comment>
  <info>string|null</info>  <strong>$extension</strong>  For decompressing, the default file extensions are <return>.phar</return> and <return>.phar.tar</return>.
                           Use this parameter to specify another file extension.  Be aware that all
                           executable phar archives must contain <return>.phar</return> in their filename.

<comment>Return:</comment>
  <info>Phar|null</info>  A <class>Phar</class> object is returned on success, and <info>null</info> on failure.

<comment>See Also:</comment>
   * <strong>PharFileInfo::getCompressedSize()</strong>
   * <strong>PharFileInfo::isCompressed()</strong>
   * <strong>PharFileInfo::compress()</strong>
   * <strong>PharFileInfo::decompress()</strong>
   * <strong>PharData::compress()</strong>
   * <strong>Phar::canCompress()</strong>
   * <strong>Phar::isCompressed()</strong>
   * <strong>Phar::compress()</strong>
   * <strong>Phar::getSupportedCompression()</strong>
   * <strong>Phar::compressFiles()</strong>
   * <strong>Phar::decompressFiles()</strong>


id: Phar::decompressFiles
type: function
doc:
<comment>Description:</comment>
  Decompresses all files in the current Phar archive
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  For tar-based phar archives, this method throws a <class>BadMethodCallException</class>, as compression of
  individual files within a tar archive is not supported by the file format.  Use <strong>Phar::compress()</strong>
  to compress an entire tar-based phar archive.
  
  For Zip-based and phar-based phar archives, this method decompresses all files in the Phar
  archive. The zlib  or bzip2 extensions must be enabled to take advantage of this feature if any
  files are compressed using bzip2/zlib compression. As with all functionality that modifies the
  contents of a phar, the phar.readonly INI variable must be off in order to succeed.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * <strong>PharFileInfo::getCompressedSize()</strong>
   * <strong>PharFileInfo::isCompressed()</strong>
   * <strong>PharFileInfo::compress()</strong>
   * <strong>PharFileInfo::decompress()</strong>
   * <strong>Phar::canCompress()</strong>
   * <strong>Phar::isCompressed()</strong>
   * <strong>Phar::compressFiles()</strong>
   * <strong>Phar::getSupportedCompression()</strong>
   * <strong>Phar::compress()</strong>
   * <strong>Phar::decompress()</strong>


id: Phar::delMetadata
type: function
doc:
<comment>Description:</comment>
  Deletes the global metadata of the phar
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  Deletes the global metadata of the phar

<comment>Return:</comment>
  <info>bool</info>  returns <info>true</info> on success, but it is better to check for thrown exception, and assume success
        if none is thrown.

<comment>See Also:</comment>
   * <strong>Phar::getMetadata()</strong>
   * <strong>Phar::setMetadata()</strong>
   * <strong>Phar::hasMetadata()</strong>


id: Phar::delete
type: function
doc:
<comment>Description:</comment>
  Delete a file within a phar archive
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  Delete a file within an archive.  This is the functional equivalent of calling <strong>unlink()</strong> on the
  stream wrapper equivalent, as shown in the example below.

<comment>Param:</comment>
  <info>string</info>  <strong>$localName</strong>  Path within an archive to the file to delete.

<comment>Return:</comment>
  <info>bool</info>  returns <info>true</info> on success, but it is better to check for thrown exception, and assume success
        if none is thrown.

<comment>See Also:</comment>
   * <strong>PharData::delete()</strong>
   * <strong>Phar::unlinkArchive()</strong>


id: Phar::extractTo
type: function
doc:
<comment>Description:</comment>
  Extract the contents of a phar archive to a directory
  
  Extract all files within a phar archive to disk.  Extracted files and directories preserve
  permissions as stored in the archive.  The optional parameters allow optional control over which
  files are extracted, and whether existing files on disk can be overwritten. The second parameter
  <strong>$files</strong> can be either the name of a file or directory to extract, or an array of names of files and
  directories to extract.  By default, this method will not overwrite existing files, the third
  parameter can be set to true to enable overwriting of files. This method is similar to
  <strong>ZipArchive::extractTo()</strong>.

<comment>Param:</comment>
  <info>string</info>             <strong>$directory</strong>  Path to extract the given <strong>$files</strong> to
  <info>array|string|null</info>  <strong>$files</strong>      The name of a file or directory to extract, or an array of
                                 files/directories to extract, <info>null</info> to skip this param
  <info>bool</info>               <strong>$overwrite</strong>  Set to <info>true</info> to enable overwriting existing files

<comment>Return:</comment>
  <info>bool</info>  returns <info>true</info> on success, but it is better to check for thrown exception, and assume success
        if none is thrown.

<comment>See Also:</comment>
   * <strong>PharData::extractTo()</strong>


id: Phar::getAlias
type: function
doc:
<comment>Description:</comment>
  Get the alias for Phar
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>string|null</info>  Returns the alias or <info>null</info> if there's no alias.


id: Phar::getMetadata
type: function
doc:
<comment>Description:</comment>
  Returns phar archive meta-data
  
  Retrieve archive meta-data.  Meta-data can be any PHP variable that can be serialized.

<comment>Return:</comment>
  <info>mixed</info>  Any PHP value that can be serialized and is stored as meta-data for the Phar archive, or
         <info>null</info> if no meta-data is stored.

<comment>See Also:</comment>
   * <strong>Phar::setMetadata()</strong>
   * <strong>Phar::delMetadata()</strong>
   * <strong>Phar::hasMetadata()</strong>


id: Phar::getModified
type: function
doc:
<comment>Description:</comment>
  Return whether phar was modified
  
  This method can be used to determine whether a phar has either had an internal file deleted, or
  contents of a file changed in some way.

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> if the phar has been modified since opened, <info>false</info> if not.


id: Phar::getPath
type: function
doc:
<comment>Description:</comment>
  Get the real path to the Phar archive on disk
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>string</info>  


id: Phar::getSignature
type: function
doc:
<comment>Description:</comment>
  Return MD5/SHA1/SHA256/SHA512/OpenSSL signature of a Phar archive
  
  Returns the verification signature of a phar archive in a hexadecimal string.

<comment>Return:</comment>
  <info>array|false</info>  Array with the opened archive's signature in <return>hash</return> key and <return>MD5</return>, <return>SHA-1</return>, <return>SHA-256</return>,
               <return>SHA-512</return>, or <return>OpenSSL</return> in <return>hash_type</return>.  This signature is a hash calculated on the entire
               phar's contents, and may be used to verify the integrity of the archive. A valid
               signature is absolutely required of all executable phar archives if the
               phar.require_hash INI variable is set to true. If there is no signature, the function
               returns <info>false</info>.


id: Phar::getStub
type: function
doc:
<comment>Description:</comment>
  Return the PHP loader or bootstrap stub of a Phar archive
  
  Phar archives contain a bootstrap loader, or <return>stub</return> written in PHP that is executed when the archive
  is executed in PHP either via include:  ]]> or by simple execution:

<comment>Return:</comment>
  <info>string</info>  Returns a string containing the contents of the bootstrap loader (stub) of the current
          Phar archive.

<comment>See Also:</comment>
   * <strong>Phar::setStub()</strong>
   * <strong>Phar::createDefaultStub()</strong>


id: Phar::getSupportedCompression
type: function
doc:
<comment>Description:</comment>
  Return array of supported compression algorithms

<comment>Return:</comment>
  <info>array</info>  Returns an array containing any of <return>Phar::GZ</return> or <return>Phar::BZ2</return>, depending on the availability of
         the zlib extension or the bz2 extension.

<comment>See Also:</comment>
   * <strong>PharFileInfo::getCompressedSize()</strong>
   * <strong>PharFileInfo::isCompressed()</strong>
   * <strong>PharFileInfo::compress()</strong>
   * <strong>PharFileInfo::decompress()</strong>
   * <strong>Phar::compress()</strong>
   * <strong>Phar::decompress()</strong>
   * <strong>Phar::canCompress()</strong>
   * <strong>Phar::isCompressed()</strong>
   * <strong>Phar::compressFiles()</strong>
   * <strong>Phar::decompressFiles()</strong>


id: Phar::getSupportedSignatures
type: function
doc:
<comment>Description:</comment>
  Return array of supported signature types
  
  Return array of supported signature types

<comment>Return:</comment>
  <info>array</info>  Returns an array containing any of <return>MD5</return>, <return>SHA-1</return>, <return>SHA-256</return>, <return>SHA-512</return>, or <return>OpenSSL</return>.

<comment>See Also:</comment>
   * <strong>Phar::getSignature()</strong>
   * <strong>Phar::setSignatureAlgorithm()</strong>


id: Phar::getVersion
type: function
doc:
<comment>Description:</comment>
  Return version info of Phar archive
  
  Returns the API version of an opened Phar archive.

<comment>Return:</comment>
  <info>string</info>  The opened archive's API version.  This is not to be confused with the API version that
          the loaded phar extension will use to create new phars.  Each Phar archive has the API
          version hard-coded into its manifest.  See Phar file format documentation for more
          information.

<comment>See Also:</comment>
   * <strong>Phar::apiVersion()</strong>


id: Phar::hasMetadata
type: function
doc:
<comment>Description:</comment>
  Returns whether phar has global meta-data
  
  Returns whether phar has global meta-data set.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> if meta-data has been set, and <info>false</info> if not.

<comment>See Also:</comment>
   * <strong>Phar::getMetadata()</strong>
   * <strong>Phar::setMetadata()</strong>
   * <strong>Phar::delMetadata()</strong>


id: Phar::interceptFileFuncs
type: function
doc:
<comment>Description:</comment>
  Instructs phar to intercept fopen, file_get_contents, opendir, and all of the stat-related
  functions
  
  instructs phar to intercept <strong>fopen()</strong>, <strong>readfile()</strong>, <strong>file_get_contents()</strong>, <strong>opendir()</strong>, and all of the
  stat-related functions.  If any of these functions is called from within a phar archive with a
  relative path, the call is modified to access a file within the phar archive.  Absolute paths are
  assumed to be attempts to load external files from the filesystem.
  
  This function makes it possible to run PHP applications designed to run off of a hard disk as a
  phar application.

<comment>Return:</comment>
  <info>void</info>  


id: Phar::isBuffering
type: function
doc:
<comment>Description:</comment>
  Used to determine whether Phar write operations are being buffered, or are flushing directly to
  disk
  
  This method can be used to determine whether a Phar will save changes to disk immediately, or
  whether a call to <strong>Phar::stopBuffering()</strong> is needed to enable saving changes.
  
  Phar write buffering is per-archive, buffering active for the <return>foo.phar</return> Phar archive does not
  affect changes to the <return>bar.phar</return> Phar archive.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> if the write operations are being buffer, <info>false</info> otherwise.

<comment>See Also:</comment>
   * <strong>Phar::startBuffering()</strong>
   * <strong>Phar::stopBuffering()</strong>


id: Phar::isCompressed
type: function
doc:
<comment>Description:</comment>
  Returns Phar::GZ or PHAR::BZ2 if the entire phar archive is compressed (.tar.gz/tar.bz and so on)
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  Returns Phar::GZ or PHAR::BZ2 if the entire phar archive is compressed (.tar.gz/tar.bz and so on).
  Zip-based phar archives cannot be compressed as a file, and so this method will always return
  <info>false</info> if a zip-based phar archive is queried.

<comment>Return:</comment>
  <info>int|false</info>  <return>Phar::GZ</return>, <return>Phar::BZ2</return> or <info>false</info>.

<comment>See Also:</comment>
   * <strong>PharFileInfo::getCompressedSize()</strong>
   * <strong>PharFileInfo::isCompressed()</strong>
   * <strong>PharFileInfo::decompress()</strong>
   * <strong>PharFileInfo::compress()</strong>
   * <strong>Phar::decompress()</strong>
   * <strong>Phar::compress()</strong>
   * <strong>Phar::canCompress()</strong>
   * <strong>Phar::compressFiles()</strong>
   * <strong>Phar::decompressFiles()</strong>
   * <strong>Phar::getSupportedCompression()</strong>


id: Phar::isFileFormat
type: function
doc:
<comment>Description:</comment>
  Returns true if the phar archive is based on the tar/phar/zip file format depending on the
  parameter

<comment>Param:</comment>
  <info>int</info>  <strong>$format</strong>  Either <return>Phar::PHAR</return>, <return>Phar::TAR</return>, or <return>Phar::ZIP</return> to test for the format of the archive.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> if the phar archive matches the file format requested by the parameter

<comment>See Also:</comment>
   * <strong>Phar::convertToExecutable()</strong>
   * <strong>Phar::convertToData()</strong>


id: Phar::isValidPharFilename
type: function
doc:
<comment>Description:</comment>
  Returns whether the given filename is a valid phar filename
  
  Returns whether the given filename is a valid phar filename that will be recognized as a phar
  archive by the phar extension.  This can be used to test a name without having to instantiate a
  phar archive and catch the inevitable Exception that will be thrown if an invalid name is
  specified.

<comment>Param:</comment>
  <info>string</info>  <strong>$filename</strong>    The name or full path to a phar archive not yet created
  <info>bool</info>    <strong>$executable</strong>  This parameter determines whether the filename should be treated as a phar
                       executable archive, or a data non-executable archive

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> if the filename is valid, <info>false</info> if not.


id: Phar::isWritable
type: function
doc:
<comment>Description:</comment>
  Returns true if the phar archive can be modified
  
  This method returns <info>true</info> if <return>phar.readonly</return> is <return>0</return>, and the actual phar archive on disk is not
  read-only.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> if the phar archive can be modified

<comment>See Also:</comment>
   * <strong>Phar::canWrite()</strong>
   * <strong>PharData::isWritable()</strong>


id: Phar::loadPhar
type: function
doc:
<comment>Description:</comment>
  Loads any phar archive with an alias
  
  This can be used to read the contents of an external Phar archive.  This is most useful for
  assigning an alias to a phar so that subsequent references to the phar can use the shorter alias,
  or for loading Phar archives that only contain data and are not intended for execution/inclusion
  in PHP scripts.

<comment>Param:</comment>
  <info>string</info>       <strong>$filename</strong>  the full or relative path to the phar archive to open
  <info>string|null</info>  <strong>$alias</strong>     The alias that may be used to refer to the phar archive.  Note that many
                          phar archives specify an explicit alias inside the phar archive, and a
                          <class>PharException</class> will be thrown if a new alias is specified in this case.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * <strong>Phar::mapPhar()</strong>


id: Phar::mapPhar
type: function
doc:
<comment>Description:</comment>
  Reads the currently executed file (a phar) and registers its manifest
  
  This static method can only be used inside a Phar archive's loader stub in order to initialize the
  phar when it is directly executed, or when it is included in another script.

<comment>Param:</comment>
  <info>string|null</info>  <strong>$alias</strong>   The alias that can be used in <return>phar://</return> URLs to refer to this archive, rather
                        than its full path.
  <info>int</info>          <strong>$offset</strong>  Unused variable, here for compatibility with PEAR's PHP_Archive.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * <strong>Phar::loadPhar()</strong>


id: Phar::mount
type: function
doc:
<comment>Description:</comment>
  Mount an external path or file to a virtual location within the phar archive
  
  Much like the unix file system concept of mounting external devices to paths within the directory
  tree, <strong>Phar::mount()</strong> allows referring to external files and directories as if they were inside of
  an archive.  This allows powerful abstraction such as referring to external configuration files as
  if they were inside the archive.

<comment>Param:</comment>
  <info>string</info>  <strong>$pharPath</strong>      The internal path within the phar archive to use as the mounted path
                         location. This must be a relative path within the phar archive, and must
                         not already exist.
  <info>string</info>  <strong>$externalPath</strong>  A path or URL to an external file or directory to mount within the phar
                         archive

<comment>Return:</comment>
  <info>void</info>  No return.  <class>PharException</class> is thrown on failure.


id: Phar::mungServer
type: function
doc:
<comment>Description:</comment>
  Defines a list of up to 4 $_SERVER variables that should be modified for execution
  
  <strong>Phar::mungServer()</strong> should only be called within the stub of a phar archive.
  
  Defines a list of up to 4 $_SERVER variables that should be modified for execution. Variables that
  can be modified to remove traces of phar execution are <return>REQUEST_URI</return>, <return>PHP_SELF</return>, <return>SCRIPT_NAME</return> and
  <return>SCRIPT_FILENAME</return>.
  
  On its own, this method does nothing.  Only when combined with <strong>Phar::webPhar()</strong> does it take
  effect, and only when the requested file is a PHP file to be parsed.  Note that the <return>PATH_INFO</return> and
  <return>PATH_TRANSLATED</return> variables are always modified.
  
  The original values of variables that are modified are stored in the SERVER array with <return>PHAR_</return>
  prepended, so for instance <return>SCRIPT_NAME</return> would be saved as <return>PHAR_SCRIPT_NAME</return>.

<comment>Param:</comment>
  <info>array</info>  <strong>$variables</strong>  An array of any of the strings <return>REQUEST_URI</return>, <return>PHP_SELF</return>, <return>SCRIPT_NAME</return> and
                     <return>SCRIPT_FILENAME</return>. Other values trigger an exception, and <strong>Phar::mungServer()</strong> is
                     case-sensitive.

<comment>Return:</comment>
  <info>void</info>  No return.

<comment>See Also:</comment>
   * <strong>Phar::webPhar()</strong>
   * <strong>Phar::setStub()</strong>


id: Phar::offsetExists
type: function
doc:
<comment>Description:</comment>
  Determines whether a file exists in the phar
  
  This is an implementation of the ArrayAccess interface allowing direct manipulation of the
  contents of a Phar archive using array access brackets.
  
  offsetExists() is called whenever <strong>isset()</strong> is called.

<comment>Param:</comment>
  <info>string</info>  <strong>$localName</strong>  The filename (relative path) to look for in a Phar.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> if the file exists within the phar, or <info>false</info> if not.

<comment>See Also:</comment>
   * <strong>Phar::offsetGet()</strong>
   * <strong>Phar::offsetSet()</strong>
   * <strong>Phar::offsetUnset()</strong>


id: Phar::offsetGet
type: function
doc:
<comment>Description:</comment>
  Gets a PharFileInfo object for a specific file
  
  This is an implementation of the ArrayAccess interface allowing direct manipulation of the
  contents of a Phar archive using array access brackets. Phar::offsetGet is used  for retrieving
  files from a Phar archive.

<comment>Param:</comment>
  <info>string</info>  <strong>$localName</strong>  The filename (relative path) to look for in a Phar.

<comment>Return:</comment>
  <info>SplFileInfo</info>  A <class>PharFileInfo</class> object is returned that can be used to iterate over a file's contents
               or to retrieve information about the current file.

<comment>See Also:</comment>
   * <strong>Phar::offsetExists()</strong>
   * <strong>Phar::offsetSet()</strong>
   * <strong>Phar::offsetUnset()</strong>


id: Phar::offsetSet
type: function
doc:
<comment>Description:</comment>
  Set the contents of an internal file to those of an external file
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  This is an implementation of the ArrayAccess interface allowing direct manipulation of the
  contents of a Phar archive using array access brackets.  offsetSet is used for modifying an
  existing file, or adding a new file to a Phar archive.

<comment>Param:</comment>
  <info>string</info>           <strong>$localName</strong>  The filename (relative path) to modify in a Phar.
  <info>resource|string</info>  <strong>$value</strong>      Content of the file.

<comment>Return:</comment>
  <info>void</info>  No return values.

<comment>See Also:</comment>
   * <strong>Phar::offsetExists()</strong>
   * <strong>Phar::offsetGet()</strong>
   * <strong>Phar::offsetUnset()</strong>


id: Phar::offsetUnset
type: function
doc:
<comment>Description:</comment>
  Remove a file from a phar
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  This is an implementation of the ArrayAccess interface allowing direct manipulation of the
  contents of a Phar archive using array access brackets.  offsetUnset is used for deleting an
  existing file, and is called by the <strong>unset()</strong> language construct.

<comment>Param:</comment>
  <info>string</info>  <strong>$localName</strong>  The filename (relative path) to modify in a Phar.

<comment>Return:</comment>
  <info>void</info>  No value is returned.

<comment>See Also:</comment>
   * <strong>Phar::offsetExists()</strong>
   * <strong>Phar::offsetGet()</strong>
   * <strong>Phar::offsetSet()</strong>
   * <strong>Phar::unlinkArchive()</strong>
   * <strong>Phar::delete()</strong>


id: Phar::running
type: function
doc:
<comment>Description:</comment>
  Returns the full path on disk or full phar URL to the currently executing Phar archive
  
  Returns the full path to the running phar archive.  This is intended for use much like the
  <return>__FILE__</return> magic constant, and only has effect inside an executing phar archive.
  
  Inside the stub of an archive, <strong>Phar::running()</strong> returns <return>""</return>.  Simply use <info>__FILE__</info> to access the
  current running phar inside a stub.

<comment>Param:</comment>
  <info>bool</info>  <strong>$returnPhar</strong>  If <info>false</info>, the full path on disk to the phar archive is returned.  If <info>true</info>, a
                     full phar URL is returned.

<comment>Return:</comment>
  <info>string</info>  Returns the filename if valid, empty string otherwise.


id: Phar::setAlias
type: function
doc:
<comment>Description:</comment>
  Set the alias for the Phar archive
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  Set the alias for the Phar archive, and write it as the permanent alias for this phar archive.  An
  alias can be used internally to a phar archive to ensure that use of the <return>phar</return> stream wrapper to
  access internal files always works regardless of the location of the phar archive on the
  filesystem.  Another alternative is to rely upon Phar's interception of <strong>include()</strong> or to use
  <strong>Phar::interceptFileFuncs()</strong> and use relative paths.

<comment>Param:</comment>
  <info>string</info>  <strong>$alias</strong>  A shorthand string that this archive can be referred to in <return>phar</return> stream wrapper
                  access.

<comment>Return:</comment>
  <info>bool</info>  

<comment>See Also:</comment>
   * <strong>Phar::__construct()</strong>
   * <strong>Phar::interceptFileFuncs()</strong>


id: Phar::setDefaultStub
type: function
doc:
<comment>Description:</comment>
  Used to set the PHP loader or bootstrap stub of a Phar archive to the default loader
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  This method is a convenience method that combines the functionality of <strong>Phar::createDefaultStub()</strong>
  and <strong>Phar::setStub()</strong>.

<comment>Param:</comment>
  <info>string|null</info>  <strong>$index</strong>     Relative path within the phar archive to run if accessed on the
                          command-line
  <info>string|null</info>  <strong>$webIndex</strong>  Relative path within the phar archive to run if accessed through a web
                          browser

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * <strong>Phar::setStub()</strong>
   * <strong>Phar::createDefaultStub()</strong>


id: Phar::setMetadata
type: function
doc:
<comment>Description:</comment>
  Sets phar archive meta-data
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  <strong>Phar::setMetadata()</strong> should be used to store customized data that describes something about the
  phar archive as a complete entity. <strong>PharFileInfo::setMetadata()</strong> should be used for file-specific
  meta-data. Meta-data can slow down the performance of loading a phar archive if the data is large.
  
  Some possible uses for meta-data include specifying which file within the archive should be used
  to bootstrap the archive, or the location of a file manifest like PEAR's package.xml file.
  However, any useful data that describes the phar archive may be stored.

<comment>Param:</comment>
  <info>mixed</info>  <strong>$metadata</strong>  Any PHP variable containing information to store that describes the phar archive

<comment>Return:</comment>
  <info>void</info>  No value is returned.

<comment>See Also:</comment>
   * <strong>Phar::getMetadata()</strong>
   * <strong>Phar::delMetadata()</strong>
   * <strong>Phar::hasMetadata()</strong>


id: Phar::setSignatureAlgorithm
type: function
doc:
<comment>Description:</comment>
  Set the signature algorithm for a phar and apply it
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  set the signature algorithm for a phar and apply it.  The signature algorithm must be one of
  <return>Phar::MD5</return>, <return>Phar::SHA1</return>, <return>Phar::SHA256</return>, <return>Phar::SHA512</return>, or <return>Phar::OPENSSL</return>.
  
  Note that all executable phar archives have a signature created automatically, <return>SHA1</return> by default.
  data tar- or zip-based archives (archives created with the <class>PharData</class> class) must have their
  signature created and set explicitly via <strong>Phar::setSignatureAlgorithm()</strong>.

<comment>Param:</comment>
  <info>int</info>          <strong>$algo</strong>        One of <return>Phar::MD5</return>, <return>Phar::SHA1</return>, <return>Phar::SHA256</return>, <return>Phar::SHA512</return>, or
                            <return>Phar::OPENSSL</return>
  <info>string|null</info>  <strong>$privateKey</strong>  The contents of an OpenSSL private key, as extracted from a certificate
                            or OpenSSL key file: setSignatureAlgorithm(Phar::OPENSSL, $pkey);
                            ?> ]]> See phar introduction for instructions on naming and placement of
                            the public key file.

<comment>Return:</comment>
  <info>void</info>  No value is returned.

<comment>See Also:</comment>
   * <strong>Phar::getSupportedSignatures()</strong>
   * <strong>Phar::getSignature()</strong>


id: Phar::setStub
type: function
doc:
<comment>Description:</comment>
  Used to set the PHP loader or bootstrap stub of a Phar archive
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  This method is used to add a PHP bootstrap loader stub to a new Phar archive, or to replace the
  loader stub in an existing Phar archive.
  
  The loader stub for a Phar archive is used whenever an archive is included directly as in this
  example:
  
  The loader is not accessed when including a file through the <return>phar</return> stream wrapper like so:

<comment>Param:</comment>
  <info>resource|string</info>  <strong>$stub</strong>    A string or an open stream handle to use as the executable stub for this
                            phar archive.
  <info>int</info>              <strong>$length</strong>  

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * <strong>Phar::getStub()</strong>
   * <strong>Phar::createDefaultStub()</strong>


id: Phar::startBuffering
type: function
doc:
<comment>Description:</comment>
  Start buffering Phar write operations, do not modify the Phar object on disk
  
  Although technically unnecessary, the <strong>Phar::startBuffering()</strong> method can provide a significant
  performance boost when creating or modifying a Phar archive with a large number of files.
  Ordinarily, every time a file within a Phar archive is created or modified in any way, the entire
  Phar archive will be recreated with the changes.  In this way, the archive will be up-to-date with
  the activity performed on it.
  
  However, this can be unnecessary when simply creating a new Phar archive, when it would make more
  sense to write the entire archive out at once. Similarly, it is often necessary to make a series
  of changes and to ensure that they all are possible before making any changes on disk, similar to
  the relational database concept of transactions.  the <strong>Phar::startBuffering()</strong>/<strong>Phar::stopBuffering()</strong>
  pair of methods is provided for this purpose.
  
  Phar write buffering is per-archive, buffering active for the <return>foo.phar</return> Phar archive does not
  affect changes to the <return>bar.phar</return> Phar archive.

<comment>Return:</comment>
  <info>void</info>  No value is returned.

<comment>See Also:</comment>
   * <strong>Phar::stopBuffering()</strong>
   * <strong>Phar::isBuffering()</strong>


id: Phar::stopBuffering
type: function
doc:
<comment>Description:</comment>
  Stop buffering write requests to the Phar archive, and save changes to disk
  
  <strong>Phar::stopBuffering()</strong> is used in conjunction with the <strong>Phar::startBuffering()</strong> method.
  <strong>Phar::startBuffering()</strong> can provide a significant performance boost when creating or modifying a
  Phar archive with a large number of files.  Ordinarily, every time a file within a Phar archive is
  created or modified in any way, the entire Phar archive will be recreated with the changes.  In
  this way, the archive will be up-to-date with the activity performed on it.
  
  However, this can be unnecessary when simply creating a new Phar archive, when it would make more
  sense to write the entire archive out at once. Similarly, it is often necessary to make a series
  of changes and to ensure that they all are possible before making any changes on disk, similar to
  the relational database concept of transactions.  The <strong>Phar::startBuffering()</strong>/<strong>Phar::stopBuffering()</strong>
  pair of methods is provided for this purpose.
  
  Phar write buffering is per-archive, buffering active for the <return>foo.phar</return> Phar archive does not
  affect changes to the <return>bar.phar</return> Phar archive.

<comment>Return:</comment>
  <info>void</info>  No value is returned.

<comment>See Also:</comment>
   * <strong>Phar::startBuffering()</strong>
   * <strong>Phar::isBuffering()</strong>


id: Phar::unlinkArchive
type: function
doc:
<comment>Description:</comment>
  Completely remove a phar archive from disk and from memory
  
  Removes a phar archive from disk and memory.

<comment>Param:</comment>
  <info>string</info>  <strong>$filename</strong>  The path on disk to the phar archive.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * <strong>Phar::delete()</strong>
   * <strong>Phar::offsetUnset()</strong>


id: Phar::webPhar
type: function
doc:
<comment>Description:</comment>
  Routes a request from a web browser to an internal file within the phar archive
  
  <strong>Phar::webPhar()</strong> serves as <strong>Phar::mapPhar()</strong> for  web-based phars.  This method parses
  $_SERVER['REQUEST_URI'] and  routes a request from a web browser to an internal file within the
  phar archive.   It simulates a web server, routing requests to the correct file, echoing the
  correct  headers and parsing PHP files as needed.  Combined with <strong>Phar::mungServer()</strong>  and
  <strong>Phar::interceptFileFuncs()</strong>, any web application can be used  unmodified from a phar archive.
  
  <strong>Phar::webPhar()</strong> should only be called from the stub of a phar archive (see here for more
  information on what a stub is).

<comment>Param:</comment>
  <info>string|null</info>    <strong>$alias</strong>               The alias that can be used in <return>phar://</return> URLs to refer to this
                                      archive, rather than its full path.
  <info>string|null</info>    <strong>$index</strong>               The location within the phar of the directory index.
  <info>string|null</info>    <strong>$fileNotFoundScript</strong>  The location of the script to run when a file is not found.
                                      This script should output the proper HTTP 404 headers.
  <info>array</info>          <strong>$mimeTypes</strong>           An array mapping additional file extensions to MIME type. If
                                      the default mapping is sufficient, pass an empty array. By
                                      default, these extensions are mapped to these MIME types:
                                      Phar::PHPS, // pass to highlight_file() 'c' => 'text/plain',
                                      'cc' => 'text/plain', 'cpp' => 'text/plain', 'c++' =>
                                      'text/plain', 'dtd' => 'text/plain', 'h' => 'text/plain',
                                      'log' => 'text/plain', 'rng' => 'text/plain', 'txt' =>
                                      'text/plain', 'xsd' => 'text/plain', 'php' => Phar::PHP, //
                                      parse as PHP 'inc' => Phar::PHP, // parse as PHP 'avi' =>
                                      'video/avi', 'bmp' => 'image/bmp', 'css' => 'text/css', 'gif'
                                      => 'image/gif', 'htm' => 'text/html', 'html' => 'text/html',
                                      'htmls' => 'text/html', 'ico' => 'image/x-ico', 'jpe' =>
                                      'image/jpeg', 'jpg' => 'image/jpeg', 'jpeg' => 'image/jpeg',
                                      'js' => 'application/x-javascript', 'midi' => 'audio/midi',
                                      'mid' => 'audio/midi', 'mod' => 'audio/mod', 'mov' =>
                                      'movie/quicktime', 'mp3' => 'audio/mp3', 'mpg' =>
                                      'video/mpeg', 'mpeg' => 'video/mpeg', 'pdf' =>
                                      'application/pdf', 'png' => 'image/png', 'swf' =>
                                      'application/shockwave-flash', 'tif' => 'image/tiff', 'tiff'
                                      => 'image/tiff', 'wav' => 'audio/wav', 'xbm' => 'image/xbm',
                                      'xml' => 'text/xml',
                                      );
                                      ?> ]]>
  <info>callable|null</info>  <strong>$rewrite</strong>             The rewrites function is passed a string as its only parameter
                                      and must return a <info>string</info> or <info>false</info>.
                                      
                                      If you are using fast-cgi or cgi then the parameter passed to
                                      the function is the value of the  $_SERVER['PATH_INFO']
                                      variable. Otherwise, the parameter passed to the function is
                                      the value of the $_SERVER['REQUEST_URI'] variable.
                                      
                                      If a string is returned it is used as the internal file path.
                                      If <info>false</info> is returned then webPhar() will send a HTTP 403
                                      Denied Code.

<comment>Return:</comment>
  <info>void</info>  No value is returned.

<comment>See Also:</comment>
   * <strong>Phar::mungServer()</strong>
   * <strong>Phar::interceptFileFuncs()</strong>


id: PharData
type: class
doc:
<comment>Description:</comment>
  The PharData class provides a high-level interface to accessing and creating non-executable tar
  and zip archives.  Because these archives do not contain a stub and cannot be executed by the phar
  extension, it is possible to create and manipulate regular zip and tar files using the PharData
  class even if <return>phar.readonly</return> php.ini setting is <return>1</return>.


id: PharData::__construct
type: function
doc:
<comment>Description:</comment>
  Construct a non-executable tar or zip archive object

<comment>Param:</comment>
  <info>string</info>       <strong>$filename</strong>  Path to an existing tar/zip archive or to-be-created archive
  <info>int</info>          <strong>$flags</strong>     Flags to pass to <class>Phar</class> parent class <class>RecursiveDirectoryIterator</class>.
  <info>string|null</info>  <strong>$alias</strong>     Alias with which this Phar archive should be referred to in calls to
                          stream functionality.
  <info>int</info>          <strong>$format</strong>    One of the file format constants available within the <class>Phar</class> class.


id: PharData::addEmptyDir
type: function
doc:
<comment>Description:</comment>
  Add an empty directory to the tar/zip archive
  
  With this method, an empty directory is created with path <return>dirname</return>. This method is similar to
  <strong>ZipArchive::addEmptyDir()</strong>.

<comment>Param:</comment>
  <info>string</info>  <strong>$directory</strong>  The name of the empty directory to create in the phar archive

<comment>Return:</comment>
  <info>void</info>  no return value, exception is thrown on failure.

<comment>See Also:</comment>
   * <strong>Phar::addEmptyDir()</strong>
   * <strong>PharData::addFile()</strong>
   * <strong>PharData::addFromString()</strong>


id: PharData::addFile
type: function
doc:
<comment>Description:</comment>
  Add a file from the filesystem to the tar/zip archive
  
  With this method, any file or URL can be added to the tar/zip archive.  If the optional second
  parameter <return>localname</return> is specified, the file will be stored in the archive with that name, otherwise
  the <return>file</return> parameter is used as the path to store within the archive.  URLs must have a localname or
  an exception is thrown. This method is similar to <strong>ZipArchive::addFile()</strong>.

<comment>Param:</comment>
  <info>string</info>       <strong>$filename</strong>   Full or relative path to a file on disk to be added to the phar archive.
  <info>string|null</info>  <strong>$localName</strong>  Path that the file will be stored in the archive.

<comment>Return:</comment>
  <info>void</info>  no return value, exception is thrown on failure.

<comment>See Also:</comment>
   * <strong>PharData::offsetSet()</strong>
   * <strong>Phar::addFile()</strong>
   * <strong>PharData::addFromString()</strong>
   * <strong>PharData::addEmptyDir()</strong>


id: PharData::addFromString
type: function
doc:
<comment>Description:</comment>
  Add a file from a string to the tar/zip archive
  
  With this method, any string can be added to the tar/zip archive. The file will be stored in the
  archive with <return>localname</return> as its path.  This method is similar to <strong>ZipArchive::addFromString()</strong>.

<comment>Param:</comment>
  <info>string</info>  <strong>$localName</strong>  Path that the file will be stored in the archive.
  <info>string</info>  <strong>$contents</strong>   The file contents to store

<comment>Return:</comment>
  <info>void</info>  no return value, exception is thrown on failure.

<comment>See Also:</comment>
   * <strong>PharData::offsetSet()</strong>
   * <strong>Phar::addFromString()</strong>
   * <strong>PharData::addFile()</strong>
   * <strong>PharData::addEmptyDir()</strong>


id: PharData::buildFromDirectory
type: function
doc:
<comment>Description:</comment>
  Construct a tar/zip archive from the files within a directory
  
  Populate a tar/zip archive from directory contents.  The optional second parameter is a regular
  expression (pcre) that is used to exclude files. Any filename that matches the regular expression
  will be included, all others will be excluded.  For more fine-grained control, use
  <strong>PharData::buildFromIterator()</strong>.

<comment>Param:</comment>
  <info>string</info>  <strong>$directory</strong>  The full or relative path to the directory that contains all files to add to
                      the archive.
  <info>string</info>  <strong>$pattern</strong>    An optional pcre regular expression that is used to filter the list of files.
                      Only file paths matching the regular expression will be included in the
                      archive.

<comment>Return:</comment>
  <info>array</info>  <strong>Phar::buildFromDirectory()</strong> returns an associative array mapping internal path of file to
         the full path of the file on the filesystem,  or <info>false</info> on failure.

<comment>See Also:</comment>
   * <strong>Phar::buildFromDirectory()</strong>
   * <strong>PharData::buildFromIterator()</strong>


id: PharData::buildFromIterator
type: function
doc:
<comment>Description:</comment>
  Construct a tar or zip archive from an iterator
  
  Populate a tar or zip archive from an iterator.  Two styles of iterators are supported, iterators
  that map the filename within the tar/zip to the name of a file on disk, and iterators like
  DirectoryIterator that return SplFileInfo objects.  For iterators that return SplFileInfo objects,
  the second parameter is required.

<comment>Param:</comment>
  <info>Traversable</info>  <strong>$iterator</strong>       Any iterator that either associatively maps tar/zip file to location
                               or returns SplFileInfo objects
  <info>string|null</info>  <strong>$baseDirectory</strong>  For iterators that return SplFileInfo objects, the portion of each
                               file's full path to remove when adding to the tar/zip archive

<comment>Return:</comment>
  <info>array</info>  <strong>PharData::buildFromIterator()</strong> returns an associative array mapping internal path of file to
         the full path of the file on the filesystem.

<comment>See Also:</comment>
   * <strong>Phar::buildFromIterator()</strong>


id: PharData::compress
type: function
doc:
<comment>Description:</comment>
  Compresses the entire tar/zip archive using Gzip or Bzip2 compression
  
  For tar archives, this method compresses the entire archive using gzip compression or bzip2
  compression.  The resulting file can be processed with the gunzip command/bunzip command, or
  accessed directly and transparently with the Phar extension.
  
  For zip archives, this method fails with an exception. The zlib extension must be enabled to
  compress with gzip compression, the bzip2 extension must be enabled in order to compress with
  bzip2 compression.
  
  In addition, this method automatically renames the archive, appending <return>.gz</return>, <return>.bz2</return> or removing the
  extension if passed <return>Phar::NONE</return> to remove compression.  Alternatively, a file extension may be
  specified with the second parameter.

<comment>Param:</comment>
  <info>int</info>          <strong>$compression</strong>  Compression must be one of <return>Phar::GZ</return>, <return>Phar::BZ2</return> to add compression, or
                             <return>Phar::NONE</return> to remove compression.
  <info>string|null</info>  <strong>$extension</strong>    By default, the extension is <return>.tar.gz</return> or <return>.tar.bz2</return> for compressing a tar,
                             and <return>.tar</return> for decompressing.

<comment>Return:</comment>
  <info>PharData|null</info>  A <class>PharData</class> object is returned on success, or <info>null</info> on failure.

<comment>See Also:</comment>
   * <strong>Phar::compress()</strong>


id: PharData::compressFiles
type: function
doc:
<comment>Description:</comment>
  Compresses all files in the current tar/zip archive
  
  For tar-based archives, this method throws a <class>BadMethodCallException</class>, as compression of individual
  files within a tar archive is not supported by the file format.  Use <strong>PharData::compress()</strong> to
  compress an entire tar-based archive.
  
  For Zip-based archives, this method compresses all files in the archive using the specified
  compression. The zlib  or bzip2 extensions must be enabled to take advantage of this feature.  In
  addition, if any files are already compressed using bzip2/zlib compression, the respective
  extension must be enabled in order to decompress the files prior to re-compressing.

<comment>Param:</comment>
  <info>int</info>  <strong>$compression</strong>  Compression must be one of <return>Phar::GZ</return>, <return>Phar::BZ2</return> to add compression, or
                     <return>Phar::NONE</return> to remove compression.

<comment>Return:</comment>
  <info>void</info>  No value is returned.

<comment>See Also:</comment>
   * <strong>PharFileInfo::getCompressedSize()</strong>
   * <strong>PharFileInfo::isCompressed()</strong>
   * <strong>PharFileInfo::compress()</strong>
   * <strong>PharFileInfo::decompress()</strong>
   * <strong>Phar::canCompress()</strong>
   * <strong>Phar::isCompressed()</strong>
   * <strong>PharData::decompressFiles()</strong>
   * <strong>Phar::getSupportedCompression()</strong>
   * <strong>PharData::compress()</strong>
   * <strong>PharData::decompress()</strong>


id: PharData::convertToData
type: function
doc:
<comment>Description:</comment>
  Convert a phar archive to a non-executable tar or zip file
  
  This method is used to convert a non-executable tar or zip archive to another non-executable
  format.
  
  If no changes are specified, this method throws a <class>BadMethodCallException</class>. This method should be
  used to convert a tar archive to zip format or vice-versa.  Although it is possible to simply
  change the compression of a tar archive using this method, it is better to use the
  <strong>PharData::compress()</strong> method for logical consistency.
  
  If successful, the method creates a new archive on disk and returns a <class>PharData</class> object.  The old
  archive is not removed from disk, and should be done manually after the process has finished.

<comment>Param:</comment>
  <info>int|null</info>     <strong>$format</strong>       This should be one of <return>Phar::TAR</return> or <return>Phar::ZIP</return>.  If set to <info>null</info>, the
                             existing file format will be preserved.
  <info>int|null</info>     <strong>$compression</strong>  This should be one of <return>Phar::NONE</return> for no whole-archive compression,
                             <return>Phar::GZ</return> for zlib-based compression, and <return>Phar::BZ2</return> for bzip-based
                             compression.
  <info>string|null</info>  <strong>$extension</strong>    This parameter is used to override the default file extension for a
                             converted archive.  Note that <return>.phar</return> cannot be used anywhere in the
                             filename for a non-executable tar or zip archive.
                             
                             If converting to a tar-based phar archive, the default extensions are
                             <return>.tar</return>, <return>.tar.gz</return>, and <return>.tar.bz2</return> depending on specified compression. For
                             zip-based archives, the default extension is <return>.zip</return>.

<comment>Return:</comment>
  <info>PharData|null</info>  The method returns a <class>PharData</class> object on success, or <info>null</info> on failure.

<comment>See Also:</comment>
   * <strong>Phar::convertToExecutable()</strong>
   * <strong>Phar::convertToData()</strong>
   * <strong>PharData::convertToExecutable()</strong>


id: PharData::convertToExecutable
type: function
doc:
<comment>Description:</comment>
  Convert a non-executable tar/zip archive to an executable phar archive
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  This method is used to convert a non-executable tar or zip archive to an executable phar archive.
  Any of the three executable file formats (phar, tar or zip) can be used, and whole-archive
  compression can also be performed.
  
  If no changes are specified, this method throws a <class>BadMethodCallException</class>.
  
  If successful, the method creates a new archive on disk and returns a <class>Phar</class> object.  The old
  archive is not removed from disk, and should be done manually after the process has finished.

<comment>Param:</comment>
  <info>int|null</info>     <strong>$format</strong>       This should be one of <return>Phar::PHAR</return>, <return>Phar::TAR</return>, or <return>Phar::ZIP</return>.  If set to
                             <info>null</info>, the existing file format will be preserved.
  <info>int|null</info>     <strong>$compression</strong>  This should be one of <return>Phar::NONE</return> for no whole-archive compression,
                             <return>Phar::GZ</return> for zlib-based compression, and <return>Phar::BZ2</return> for bzip-based
                             compression.
  <info>string|null</info>  <strong>$extension</strong>    This parameter is used to override the default file extension for a
                             converted archive.  Note that all zip- and tar-based phar archives must
                             contain <return>.phar</return> in their file extension in order to be processed as a
                             phar archive.
                             
                             If converting to a phar-based archive, the default extensions are
                             <return>.phar</return>, <return>.phar.gz</return>, or <return>.phar.bz2</return> depending on the specified compression.
                             For tar-based phar archives, the default extensions are <return>.phar.tar</return>,
                             <return>.phar.tar.gz</return>, and <return>.phar.tar.bz2</return>.  For zip-based phar archives, the
                             default extension is <return>.phar.zip</return>.

<comment>Return:</comment>
  <info>Phar|null</info>  The method returns a <class>Phar</class> object on success, or <info>null</info> on failure.

<comment>See Also:</comment>
   * <strong>Phar::convertToExecutable()</strong>
   * <strong>Phar::convertToData()</strong>
   * <strong>PharData::convertToData()</strong>


id: PharData::copy
type: function
doc:
<comment>Description:</comment>
  Copy a file internal to the phar archive to another new file within the phar
  
  Copy a file internal to the tar/zip archive to another new file within the same archive. This is
  an object-oriented alternative to using <strong>copy()</strong> with the phar stream wrapper.

<comment>Param:</comment>
  <info>string</info>  <strong>$from</strong>  
  <info>string</info>  <strong>$to</strong>    

<comment>Return:</comment>
  <info>bool</info>  returns <info>true</info> on success, but it is safer to encase method call in a try/catch block and
        assume success if no exception is thrown.


id: PharData::decompress
type: function
doc:
<comment>Description:</comment>
  Decompresses the entire Phar archive
  
  For tar-based archives, this method decompresses the entire archive.
  
  For Zip-based archives, this method fails with an exception. The zlib extension must be enabled to
  decompress an archive compressed with gzip compression, and the bzip2 extension must be enabled in
  order to decompress an archive compressed with bzip2 compression.
  
  In addition, this method automatically renames the file extension of the archive, <return>.tar</return> by default.
  Alternatively, a file extension may be specified with the <strong>$extension</strong> parameter.

<comment>Param:</comment>
  <info>string|null</info>  <strong>$extension</strong>  For decompressing, the default file extension is <return>.tar</return>. Use this parameter
                           to specify another file extension. Be aware that only executable archives
                           can contain <return>.phar</return> in their filename.

<comment>Return:</comment>
  <info>PharData|null</info>  A <class>PharData</class> object is returned on success, or <info>null</info> on failure.

<comment>See Also:</comment>
   * <strong>PharFileInfo::getCompressedSize()</strong>
   * <strong>PharFileInfo::isCompressed()</strong>
   * <strong>PharFileInfo::compress()</strong>
   * <strong>PharFileInfo::decompress()</strong>
   * <strong>PharData::compress()</strong>
   * <strong>Phar::canCompress()</strong>
   * <strong>Phar::isCompressed()</strong>
   * <strong>PharData::compress()</strong>
   * <strong>Phar::getSupportedCompression()</strong>
   * <strong>PharData::compressFiles()</strong>
   * <strong>PharData::decompressFiles()</strong>


id: PharData::decompressFiles
type: function
doc:
<comment>Description:</comment>
  Decompresses all files in the current zip archive
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  For tar-based archives, this method throws a <class>BadMethodCallException</class>, as compression of individual
  files within a tar archive is not supported by the file format.  Use <strong>PharData::compress()</strong> to
  compress an entire tar-based archive.
  
  For Zip-based archives, this method decompresses all files in the archive. The zlib  or bzip2
  extensions must be enabled to take advantage of this feature if any files are compressed using
  bzip2/zlib compression.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * <strong>PharFileInfo::getCompressedSize()</strong>
   * <strong>PharFileInfo::isCompressed()</strong>
   * <strong>PharFileInfo::compress()</strong>
   * <strong>PharFileInfo::decompress()</strong>
   * <strong>Phar::canCompress()</strong>
   * <strong>Phar::isCompressed()</strong>
   * <strong>PharData::compressFiles()</strong>
   * <strong>Phar::getSupportedCompression()</strong>
   * <strong>PharData::compress()</strong>
   * <strong>PharData::decompress()</strong>


id: PharData::delMetadata
type: function
doc:
<comment>Description:</comment>
  Deletes the global metadata of a zip archive
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  Deletes the global metadata of the zip archive

<comment>Return:</comment>
  <info>bool</info>  returns <info>true</info> on success, but it is better to check for thrown exception, and assume success
        if none is thrown.

<comment>See Also:</comment>
   * <strong>Phar::delMetadata()</strong>


id: PharData::delete
type: function
doc:
<comment>Description:</comment>
  Delete a file within a tar/zip archive
  
  Delete a file within an archive.  This is the functional equivalent of calling <strong>unlink()</strong> on the
  stream wrapper equivalent, as shown in the example below.

<comment>Param:</comment>
  <info>string</info>  <strong>$localName</strong>  Path within an archive to the file to delete.

<comment>Return:</comment>
  <info>bool</info>  returns <info>true</info> on success, but it is better to check for thrown exception, and assume success
        if none is thrown.

<comment>See Also:</comment>
   * <strong>Phar::delete()</strong>


id: PharData::extractTo
type: function
doc:
<comment>Description:</comment>
  Extract the contents of a tar/zip archive to a directory
  
  Extract all files within a tar/zip archive to disk.  Extracted files and directories preserve
  permissions as stored in the archive.  The optional parameters allow optional control over which
  files are extracted, and whether existing files on disk can be overwritten. The second parameter
  <return>files</return> can be either the name of a file or directory to extract, or an array of names of files and
  directories to extract.  By default, this method will not overwrite existing files, the third
  parameter can be set to true to enable overwriting of files. This method is similar to
  <strong>ZipArchive::extractTo()</strong>.

<comment>Param:</comment>
  <info>string</info>             <strong>$directory</strong>  Path to extract the given <return>files</return> to
  <info>array|string|null</info>  <strong>$files</strong>      The name of a file or directory to extract, or an array of
                                 files/directories to extract
  <info>bool</info>               <strong>$overwrite</strong>  Set to <info>true</info> to enable overwriting existing files

<comment>Return:</comment>
  <info>bool</info>  returns <info>true</info> on success, but it is better to check for thrown exception, and assume success
        if none is thrown.

<comment>See Also:</comment>
   * <strong>Phar::extractTo()</strong>


id: PharData::isWritable
type: function
doc:
<comment>Description:</comment>
  Returns true if the tar/zip archive can be modified
  
  This method returns <info>true</info> if the tar/zip archive on disk is not read-only. Unlike
  <strong>Phar::isWritable()</strong>, data-only tar/zip archives can be modified even if <return>phar.readonly</return> is set to <return>1</return>.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> if the tar/zip archive can be modified

<comment>See Also:</comment>
   * <strong>Phar::canWrite()</strong>
   * <strong>Phar::isWritable()</strong>


id: PharData::offsetSet
type: function
doc:
<comment>Description:</comment>
  Set the contents of a file within the tar/zip to those of an external file or string
  
  This is an implementation of the ArrayAccess interface allowing direct manipulation of the
  contents of a tar/zip archive using array access brackets.  offsetSet is used for modifying an
  existing file, or adding a new file to a tar/zip archive.

<comment>Param:</comment>
  <info>string</info>           <strong>$localName</strong>  The filename (relative path) to modify in a tar or zip archive.
  <info>resource|string</info>  <strong>$value</strong>      Content of the file.

<comment>Return:</comment>
  <info>void</info>  No return values.

<comment>See Also:</comment>
   * <strong>Phar::offsetSet()</strong>


id: PharData::offsetUnset
type: function
doc:
<comment>Description:</comment>
  Remove a file from a tar/zip archive
  
  This is an implementation of the ArrayAccess interface allowing direct manipulation of the
  contents of a tar/zip archive using array access brackets.  offsetUnset is used for deleting an
  existing file, and is called by the <strong>unset()</strong> language construct.

<comment>Param:</comment>
  <info>string</info>  <strong>$localName</strong>  The filename (relative path) to modify in the tar/zip archive.

<comment>Return:</comment>
  <info>void</info>  No value is returned.

<comment>See Also:</comment>
   * <strong>Phar::offsetUnset()</strong>


id: PharData::setAlias
type: function
doc:
<comment>Description:</comment>
  Dummy function (Phar::setAlias is not valid for PharData)
  
  Non-executable tar/zip archives cannot have an alias, so this method simply throws an exception.

<comment>Param:</comment>
  <info>string</info>  <strong>$alias</strong>  A shorthand string that this archive can be referred to in <return>phar</return> stream wrapper
                  access.  This parameter is ignored.

<comment>Return:</comment>
  <info>bool</info>  

<comment>See Also:</comment>
   * <strong>Phar::setAlias()</strong>


id: PharData::setDefaultStub
type: function
doc:
<comment>Description:</comment>
  Dummy function (Phar::setDefaultStub is not valid for PharData)
  
  Non-executable tar/zip archives cannot have a stub, so this method simply throws an exception.

<comment>Param:</comment>
  <info>string|null</info>  <strong>$index</strong>     Relative path within the phar archive to run if accessed on the
                          command-line
  <info>string|null</info>  <strong>$webIndex</strong>  Relative path within the phar archive to run if accessed through a web
                          browser

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * <strong>Phar::setDefaultStub()</strong>


id: PharData::setSignatureAlgorithm
type: function
doc:
<comment>Description:</comment>
  Set the signature algorithm for a phar and apply it
  
  This
  method requires the php.ini setting <return>phar.readonly</return> to be
  set to <return>0</return> in order to work for <class>Phar</class>
  objects.  Otherwise, a <class>PharException</class> will be thrown.
  
  Set the signature algorithm for a phar and apply it.  The signature algorithm must be one of
  <return>Phar::MD5</return>, <return>Phar::SHA1</return>, <return>Phar::SHA256</return>, <return>Phar::SHA512</return>, or <return>Phar::OPENSSL</return>.

<comment>Param:</comment>
  <info>int</info>  <strong>$algo</strong>  One of <return>Phar::MD5</return>, <return>Phar::SHA1</return>, <return>Phar::SHA256</return>, <return>Phar::SHA512</return>, or <return>Phar::OPENSSL</return>

<comment>Return:</comment>
  <info>void</info>  No value is returned.

<comment>See Also:</comment>
   * <strong>Phar::getSupportedSignatures()</strong>
   * <strong>Phar::getSignature()</strong>


id: PharData::setStub
type: function
doc:
<comment>Description:</comment>
  Dummy function (Phar::setStub is not valid for PharData)
  
  Non-executable tar/zip archives cannot have a stub, so this method simply throws an exception.

<comment>Param:</comment>
  <info>string</info>  <strong>$stub</strong>  A string or an open stream handle to use as the executable stub for this phar
                 archive.  This parameter is ignored.
  <info>int</info>     <strong>$len</strong>   

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * <strong>Phar::setStub()</strong>


id: PharFileInfo
type: class
doc:
<comment>Description:</comment>
  The PharFileInfo class provides a high-level interface to the contents and attributes of a single
  file within a phar archive.


id: PharFileInfo::__construct
type: function
doc:
<comment>Description:</comment>
  Construct a Phar entry object
  
  This should not be called directly.  Instead, a PharFileInfo object is initialized by calling
  <strong>Phar::offsetGet()</strong> through array access.

<comment>Param:</comment>
  <info>string</info>  <strong>$filename</strong>  The full url to retrieve a file.  If you wish to retrieve the information for
                     the file <return>my/file.php</return> from the phar <return>boo.phar</return>, the entry should be
                     <return>phar://boo.phar/my/file.php</return>.


id: PharFileInfo::chmod
type: function
doc:
<comment>Description:</comment>
  Sets file-specific permission bits
  
  <strong>PharFileInfo::chmod()</strong> allows setting of the executable file permissions bit, as well as read-only
  bits.  Writeable bits are ignored, and set at runtime based on the phar.readonly INI variable. As
  with all functionality that modifies the contents of a phar, the phar.readonly INI variable must
  be off in order to succeed if the file is within a <class>Phar</class> archive.  Files within <class>PharData</class> archives
  do not have this restriction.

<comment>Param:</comment>
  <info>int</info>  <strong>$perms</strong>  permissions (see <strong>chmod()</strong>)

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: PharFileInfo::compress
type: function
doc:
<comment>Description:</comment>
  Compresses the current Phar entry with either zlib or bzip2 compression
  
  This method compresses the file inside the Phar archive using either bzip2 compression or zlib
  compression. The bzip2 or zlib extension must be enabled to take advantage of this feature.  In
  addition, if the file is already compressed, the respective extension must be enabled in order to
  decompress the file.  As with all functionality that modifies the contents of a phar, the
  phar.readonly INI variable must be off in order to succeed if the file is within a <class>Phar</class> archive.
  Files within <class>PharData</class> archives do not have this restriction.

<comment>Param:</comment>
  <info>int</info>  <strong>$compression</strong>  Compression must be <info>Phar::GZ</info> or <info>Phar::BZ2</info>.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * <strong>PharFileInfo::getCompressedSize()</strong>
   * <strong>PharFileInfo::isCompressed()</strong>
   * <strong>PharFileInfo::decompress()</strong>
   * <strong>Phar::canCompress()</strong>
   * <strong>Phar::isCompressed()</strong>
   * <strong>Phar::compressFiles()</strong>
   * <strong>Phar::decompressFiles()</strong>
   * <strong>Phar::compress()</strong>
   * <strong>Phar::decompress()</strong>
   * <strong>Phar::getSupportedCompression()</strong>


id: PharFileInfo::decompress
type: function
doc:
<comment>Description:</comment>
  Decompresses the current Phar entry within the phar
  
  This method decompresses the file inside the Phar archive. Depending on how the file is
  compressed, the bzip2 or zlib extensions must be enabled to take advantage of this feature.  As
  with all functionality that modifies the contents of a phar, the phar.readonly INI variable must
  be off in order to succeed if the file is within a <class>Phar</class> archive.  Files within <class>PharData</class> archives
  do not have this restriction.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * <strong>PharFileInfo::getCompressedSize()</strong>
   * <strong>PharFileInfo::isCompressed()</strong>
   * <strong>PharFileInfo::compress()</strong>
   * <strong>Phar::canCompress()</strong>
   * <strong>Phar::isCompressed()</strong>
   * <strong>Phar::compressFiles()</strong>
   * <strong>Phar::decompressFiles()</strong>
   * <strong>Phar::compress()</strong>
   * <strong>Phar::decompress()</strong>
   * <strong>Phar::getSupportedCompression()</strong>


id: PharFileInfo::delMetadata
type: function
doc:
<comment>Description:</comment>
  Deletes the metadata of the entry
  
  Deletes the metadata of the entry, if any.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> if successful, <info>false</info> if the entry had no metadata. As with all functionality
        that modifies the contents of a phar, the phar.readonly INI variable must be off in order to
        succeed if the file is within a <class>Phar</class> archive.  Files within <class>PharData</class> archives do not have
        this restriction.

<comment>See Also:</comment>
   * <strong>PharFileInfo::setMetadata()</strong>
   * <strong>PharFileInfo::hasMetadata()</strong>
   * <strong>PharFileInfo::getMetadata()</strong>
   * <strong>Phar::setMetadata()</strong>
   * <strong>Phar::hasMetadata()</strong>
   * <strong>Phar::getMetadata()</strong>


id: PharFileInfo::getCRC32
type: function
doc:
<comment>Description:</comment>
  Returns CRC32 code or throws an exception if CRC has not been verified
  
  This returns the <strong>crc32()</strong> checksum of the file within the Phar archive.

<comment>Return:</comment>
  <info>int</info>  The <strong>crc32()</strong> checksum of the file within the Phar archive.


id: PharFileInfo::getCompressedSize
type: function
doc:
<comment>Description:</comment>
  Returns the actual size of the file (with compression) inside the Phar archive
  
  This returns the size of the file within the Phar archive.  Uncompressed files will return the
  same value for getCompressedSize as they will with <strong>filesize()</strong>

<comment>Return:</comment>
  <info>int</info>  The size in bytes of the file within the Phar archive on disk.

<comment>See Also:</comment>
   * <strong>PharFileInfo::isCompressed()</strong>
   * <strong>PharFileInfo::decompress()</strong>
   * <strong>PharFileInfo::compress()</strong>
   * <strong>Phar::canCompress()</strong>
   * <strong>Phar::isCompressed()</strong>
   * <strong>Phar::compress()</strong>
   * <strong>Phar::decompress()</strong>
   * <strong>Phar::getSupportedCompression()</strong>
   * <strong>Phar::decompressFiles()</strong>
   * <strong>Phar::compressFiles()</strong>


id: PharFileInfo::getContent
type: function
doc:
<comment>Description:</comment>
  Get the complete file contents of the entry
  
  This function behaves like <strong>file_get_contents()</strong> but for Phar.

<comment>Return:</comment>
  <info>string</info>  Returns the file contents.


id: PharFileInfo::getMetadata
type: function
doc:
<comment>Description:</comment>
  Returns file-specific meta-data saved with a file
  
  Return meta-data that was saved in the Phar archive's manifest for this file.

<comment>Return:</comment>
  <info>mixed</info>  any PHP variable that can be serialized and is stored as meta-data for the file, or <info>null</info> if
         no meta-data is stored.

<comment>See Also:</comment>
   * <strong>PharFileInfo::setMetadata()</strong>
   * <strong>PharFileInfo::hasMetadata()</strong>
   * <strong>PharFileInfo::delMetadata()</strong>
   * <strong>Phar::setMetadata()</strong>
   * <strong>Phar::hasMetadata()</strong>
   * <strong>Phar::getMetadata()</strong>


id: PharFileInfo::getPharFlags
type: function
doc:
<comment>Description:</comment>
  Returns the Phar file entry flags
  
  This returns the flags set in the manifest for a Phar.  This will always return <return>0</return> in the current
  implementation.

<comment>Return:</comment>
  <info>int</info>  The Phar flags (always <return>0</return> in the current implementation)


id: PharFileInfo::hasMetadata
type: function
doc:
<comment>Description:</comment>
  Returns the metadata of the entry
  
  Returns the metadata of a file within a phar archive.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>false</info> if no metadata is set or is <info>null</info>, <info>true</info> if metadata is not <info>null</info>

<comment>See Also:</comment>
   * <strong>PharFileInfo::setMetadata()</strong>
   * <strong>PharFileInfo::getMetadata()</strong>
   * <strong>PharFileInfo::delMetadata()</strong>
   * <strong>Phar::setMetadata()</strong>
   * <strong>Phar::hasMetadata()</strong>
   * <strong>Phar::getMetadata()</strong>


id: PharFileInfo::isCRCChecked
type: function
doc:
<comment>Description:</comment>
  Returns whether file entry has had its CRC verified
  
  This returns whether a file within a Phar archive has had its CRC verified.

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> if the file has had its CRC verified, <info>false</info> if not.


id: PharFileInfo::isCompressed
type: function
doc:
<comment>Description:</comment>
  Returns whether the entry is compressed
  
  This returns whether a file is compressed within a Phar archive with either Gzip or Bzip2
  compression.

<comment>Param:</comment>
  <info>int|null</info>  <strong>$compression</strong>  One of <info>Phar::GZ</info> or <info>Phar::BZ2</info>, defaults to any compression.

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> if the file is compressed within the Phar archive, <info>false</info> if not.

<comment>See Also:</comment>
   * <strong>PharFileInfo::getCompressedSize()</strong>
   * <strong>PharFileInfo::decompress()</strong>
   * <strong>PharFileInfo::compress()</strong>
   * <strong>Phar::decompress()</strong>
   * <strong>Phar::compress()</strong>
   * <strong>Phar::canCompress()</strong>
   * <strong>Phar::isCompressed()</strong>
   * <strong>Phar::getSupportedCompression()</strong>
   * <strong>Phar::decompressFiles()</strong>
   * <strong>Phar::compressFiles()</strong>


id: PharFileInfo::setMetadata
type: function
doc:
<comment>Description:</comment>
  Sets file-specific meta-data saved with a file
  
  <strong>PharFileInfo::setMetadata()</strong> should only be used to store customized data in a file that cannot be
  represented with existing information stored with a file. Meta-data can significantly slow down
  the performance of loading a phar archive if the data is large, or if there are many files
  containing meta-data. It is important to note that file permissions are natively supported inside
  a phar; it is possible to set them with the <strong>PharFileInfo::chmod()</strong> method.  As with all
  functionality that modifies the contents of a phar, the phar.readonly INI variable must be off in
  order to succeed if the file is within a <class>Phar</class> archive.  Files within <class>PharData</class> archives do not have
  this restriction.
  
  Some possible uses for meta-data include passing a user/group that should be set when a file is
  extracted from the phar to disk.  Other uses could include explicitly specifying a MIME type to
  return.  However, any useful data that describes a file, but should not be contained inside of it
  may be stored.

<comment>Param:</comment>
  <info>mixed</info>  <strong>$metadata</strong>  Any PHP variable containing information to store alongside a file

<comment>Return:</comment>
  <info>void</info>  No value is returned.

<comment>See Also:</comment>
   * <strong>PharFileInfo::hasMetadata()</strong>
   * <strong>PharFileInfo::getMetadata()</strong>
   * <strong>PharFileInfo::delMetadata()</strong>
   * <strong>Phar::setMetadata()</strong>
   * <strong>Phar::hasMetadata()</strong>
   * <strong>Phar::getMetadata()</strong>


id: PhpToken
type: class
doc:
<comment>Description:</comment>
  This class provides an alternative to <strong>token_get_all()</strong>. While the function returns tokens either as
  a single-character string, or an array with a token ID, token text and line number,
  <strong>PhpToken::tokenize()</strong> normalizes all tokens into PhpToken objects, which makes code operating on
  tokens more memory efficient and readable.


id: PhpToken::__construct
type: function
doc:
<comment>Description:</comment>
  Returns a new PhpToken object
  
  Returns a new PhpToken object

<comment>Param:</comment>
  <info>int</info>     <strong>$id</strong>    One of the T_* constants (see ), or an ASCII codepoint representing a single-char
                 token.
  <info>string</info>  <strong>$text</strong>  The textual content of the token.
  <info>int</info>     <strong>$line</strong>  The starting line number (1-based) of the token.
  <info>int</info>     <strong>$pos</strong>   The starting position (0-based) in the tokenized string (the number of bytes).

<comment>See Also:</comment>
   * <strong>PhpToken::tokenize()</strong>


id: PhpToken::__toString
type: function
doc:
<comment>Description:</comment>
  Returns the textual content of the token.
  
  Returns the textual content of the token.

<comment>Return:</comment>
  <info>string</info>  A textual content of the token.

<comment>See Also:</comment>
   * <strong>token_name()</strong>


id: PhpToken::getTokenName
type: function
doc:
<comment>Description:</comment>
  Returns the name of the token.
  
  Returns the name of the token.

<comment>Return:</comment>
  <info>string|null</info>  An ASCII character for single-char tokens, or one of T_* constant names for known
               tokens (see ), or <info>null</info> for unknown tokens.

<comment>See Also:</comment>
   * <strong>PhpToken::tokenize()</strong>
   * <strong>token_name()</strong>


id: PhpToken::is
type: function
doc:
<comment>Description:</comment>
  Tells whether the token is of given kind.
  
  Tells whether the token is of given <strong>$kind</strong>.

<comment>Param:</comment>
  <info>int|string|array</info>  <strong>$kind</strong>  Either a single value to match the token's id or textual content, or an
                           array thereof.

<comment>Return:</comment>
  <info>bool</info>  A boolean value whether the token is of given kind.

<comment>See Also:</comment>
   * <strong>token_name()</strong>


id: PhpToken::isIgnorable
type: function
doc:
<comment>Description:</comment>
  Tells whether the token would be ignored by the PHP parser.
  
  Tells whether the token would be ignored by the PHP parser.

<comment>Return:</comment>
  <info>bool</info>  A boolean value whether the token would be ignored by the PHP parser (such as whitespace or
        comments).

<comment>See Also:</comment>
   * <strong>PhpToken::tokenize()</strong>


id: PhpToken::tokenize
type: function
doc:
<comment>Description:</comment>
  Splits given source into PHP tokens, represented by PhpToken objects.
  
  Returns an array of PhpToken objects representing given <strong>$code</strong>.

<comment>Param:</comment>
  <info>string</info>  <strong>$code</strong>   The PHP source to parse.
  <info>int</info>     <strong>$flags</strong>  Valid flags: <info>TOKEN_PARSE</info> - Recognises the ability to use reserved words in
                  specific contexts.
                  
                  <info>TOKEN_PARSE</info> - Recognises the ability to use reserved words in specific contexts.

<comment>Return:</comment>
  <info>array</info>  An array of PHP tokens represented by instances of PhpToken or its descendants. This method
         returns <info>static[]</info> so that PhpToken can be seamlessly extended.

<comment>See Also:</comment>
   * <strong>token_get_all()</strong>


id: Pool
type: class
doc:
<comment>Description:</comment>
  A Pool is a container for, and controller of, an adjustable number of Workers.
  
  Pooling provides a higher level abstraction of the Worker functionality, including the management
  of references in the way required by pthreads.


id: Pool::__construct
type: function
doc:
<comment>Description:</comment>
  Creates a new Pool of Workers
  
  Construct a new pool of workers. Pools lazily create their threads, which means new threads will
  only be spawned when they are required to execute tasks.

<comment>Param:</comment>
  <info>int</info>     <strong>$size</strong>   The maximum number of workers for this pool to create
  <info>string</info>  <strong>$class</strong>  The class for new Workers. If no class is given, then it defaults to the <class>Worker</class>
                  class.
  <info>array</info>   <strong>$ctor</strong>   An array of arguments to be passed to new workers' constructors


id: Pool::collect
type: function
doc:
<comment>Description:</comment>
  Collect references to completed tasks
  
  Allows the pool to collect references determined to be garbage by the optionally given collector.

<comment>Param:</comment>
  <info>Callable</info>  <strong>$collector</strong>  A Callable collector that returns a boolean on whether the task can be
                        collected or not. Only in rare cases should a custom collector need to be
                        used.

<comment>Return:</comment>
  <info>int</info>  The number of remaining tasks in the pool to be collected.


id: Pool::resize
type: function
doc:
<comment>Description:</comment>
  Resize the Pool
  
  Resize the Pool

<comment>Param:</comment>
  <info>int</info>  <strong>$size</strong>  The maximum number of Workers this Pool can create

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Pool::shutdown
type: function
doc:
<comment>Description:</comment>
  Shutdown all workers
  
  Shuts down all of the workers in the pool. This will block until all submitted tasks have been
  executed.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Pool::submit
type: function
doc:
<comment>Description:</comment>
  Submits an object for execution
  
  Submit the task to the next Worker in the Pool

<comment>Param:</comment>
  <info>Threaded</info>  <strong>$task</strong>  The task for execution

<comment>Return:</comment>
  <info>int</info>  the identifier of the Worker executing the object


id: Pool::submitTo
type: function
doc:
<comment>Description:</comment>
  Submits a task to a specific worker for execution
  
  Submit a task to the specified worker in the pool. The workers are indexed from 0, and will only
  exist if the pool has needed to create them (since threads are lazily spawned).

<comment>Param:</comment>
  <info>int</info>       <strong>$worker</strong>  The worker to stack the task onto, indexed from <return>0</return>.
  <info>Threaded</info>  <strong>$task</strong>    The task for execution.

<comment>Return:</comment>
  <info>int</info>  The identifier of the worker that accepted the task.


id: QuickHashIntHash
type: class
doc:
<comment>Description:</comment>
  This class wraps around a hash containing integer numbers, where the values are also integer
  numbers. Hashes are also available as implementation of the ArrayAccess interface.
  
  Hashes can also be iterated over with <return>foreach</return> as the Iterator interface is implemented as well.
  The order of which elements are returned in is not guaranteed.


id: QuickHashIntHash::CHECK_FOR_DUPES
type: constant
doc:
<comment>Description:</comment>
  If enabled, adding duplicate elements to a set (through either QuickHashIntHash::add or
  QuickHashIntHash::loadFromFile) will result in those elements to be dropped from the set. This
  will take up extra time, so only used when it is required.


id: QuickHashIntHash::DO_NOT_USE_ZEND_ALLOC
type: constant
doc:
<comment>Description:</comment>
  Disables the use of PHP's internal memory manager for internal set structures. With this option
  enabled, internal allocations will not count towards the memory_limit settings.


id: QuickHashIntHash::HASHER_JENKINS1
type: constant
doc:
<comment>Description:</comment>
  This is the default hashing function to turn the integer hashes into bucket list indexes.


id: QuickHashIntHash::HASHER_NO_HASH
type: constant
doc:
<comment>Description:</comment>
  Selects to not use a hashing function, but merely use a modulo to find the bucket list index. This
  is not faster than normal hashing, and gives more collisions.


id: QuickHashIntHash::__construct
type: function
doc:
<comment>Description:</comment>
  Creates a new QuickHashIntHash object
  
  This constructor creates a new <class>QuickHashIntHash</class>. The size is the amount of bucket lists to create.
  The more lists there are, the less collisions you will have. Options are also supported.

<comment>Param:</comment>
  <info>int</info>  <strong>$size</strong>     The amount of bucket lists to configure. The number you pass in will be
                 automatically rounded up to the next power of two. It is also automatically limited
                 from <return>64</return> to <return>4194304</return>.
  <info>int</info>  <strong>$options</strong>  The options that you can pass in are: <info>QuickHashIntHash::CHECK_FOR_DUPES</info>, which
                 makes sure no duplicate entries are added to the hash;
                 <info>QuickHashIntHash::DO_NOT_USE_ZEND_ALLOC</info> to not use PHP's internal memory manager as
                 well as one of <info>QuickHashIntHash::HASHER_NO_HASH</info>, <info>QuickHashIntHash::HASHER_JENKINS1</info>
                 or <info>QuickHashIntHash::HASHER_JENKINS2</info>. These last three configure which hashing
                 algorithm to use. All options can be combined using bitmasks.

<comment>Return:</comment>
  <info>unknown</info>  Returns a new <class>QuickHashIntHash</class> object.


id: QuickHashIntHash::add
type: function
doc:
<comment>Description:</comment>
  This method adds a new entry to the hash
  
  This method adds a new entry to the hash, and returns whether the entry was added. Entries are by
  default always added unless <info>QuickHashIntHash::CHECK_FOR_DUPES</info> has been passed when the hash was
  created.

<comment>Param:</comment>
  <info>int</info>  <strong>$key</strong>    The key of the entry to add.
  <info>int</info>  <strong>$value</strong>  The optional value of the entry to add. If no value is specified, <return>1</return> will be used.

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> when the entry was added, and <info>false</info> if the entry was not added.


id: QuickHashIntHash::delete
type: function
doc:
<comment>Description:</comment>
  This method deletes an entry from the hash
  
  This method deletes an entry from the hash, and returns whether the entry was deleted or not.
  Associated memory structures will not be freed immediately, but rather when the hash itself is
  freed.
  
  Elements can not be deleted when the hash is used in an iterator. The method will not throw an
  exception, but simply return <info>false</info> like would happen with any other deletion failure.

<comment>Param:</comment>
  <info>int</info>  <strong>$key</strong>  The key of the entry to delete.

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> when the entry was deleted, and <info>false</info> if the entry was not deleted.


id: QuickHashIntHash::exists
type: function
doc:
<comment>Description:</comment>
  This method checks whether a key is part of the hash
  
  This method checks whether an entry with the provided key exists in the hash.

<comment>Param:</comment>
  <info>int</info>  <strong>$key</strong>  The key of the entry to check for whether it exists in the hash.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> when the entry was found, or <info>false</info> when the entry is not found.


id: QuickHashIntHash::get
type: function
doc:
<comment>Description:</comment>
  This method retrieves a value from the hash by its key
  
  This method retrieves a value from the hash by its key.

<comment>Param:</comment>
  <info>int</info>  <strong>$key</strong>  The key of the entry to retrieve.

<comment>Return:</comment>
  <info>int</info>  The value if the key exists, or <info>null</info> if the key wasn't part of the hash.


id: QuickHashIntHash::getSize
type: function
doc:
<comment>Description:</comment>
  Returns the number of elements in the hash
  
  Returns the number of elements in the hash.

<comment>Return:</comment>
  <info>int</info>  The number of elements in the hash.


id: QuickHashIntHash::loadFromFile
type: function
doc:
<comment>Description:</comment>
  This factory method creates a hash from a file
  
  This factory method creates a new hash from a definition file on disk. The file format consists of
  a signature <return>'QH\0x11\0'</return>, the number of elements as a 32 bit signed integer in system Endianness,
  followed by 32 bit signed integers packed together in the Endianness that the system that the code
  runs on uses. For each hash element there are two 32 bit signed integers stored. The first of each
  element is the key, and the second is the value belonging to the key. An example could be:
  
  QuickHash IntHash file format
  
  QuickHash IntHash file format

<comment>Param:</comment>
  <info>string</info>  <strong>$filename</strong>  The filename of the file to read the hash from.
  <info>int</info>     <strong>$options</strong>   The same options that the class' constructor takes; except that the size option
                     is ignored. It is automatically calculated to be the same as the number of
                     entries in the hash, rounded up to the nearest power of two with a maximum
                     limit of <return>4194304</return>.

<comment>Return:</comment>
  <info>QuickHashIntHash</info>  Returns a new <class>QuickHashIntHash</class>.


id: QuickHashIntHash::loadFromString
type: function
doc:
<comment>Description:</comment>
  This factory method creates a hash from a string
  
  This factory method creates a new hash from a definition in a string. The file format consists of
  32 bit signed integers packed together in the Endianness that the system that the code runs on
  uses. For each element there are two 32 bit signed integers stored. The first of each element is
  the key, and the second is the value belonging to the key.

<comment>Param:</comment>
  <info>string</info>  <strong>$contents</strong>  The string containing a serialized format of the hash.
  <info>int</info>     <strong>$options</strong>   The same options that the class' constructor takes; except that the size option
                     is ignored. It is automatically calculated to be the same as the number of
                     entries in the hash, rounded up to the nearest power of two with a maximum
                     limit of <return>4194304</return>.

<comment>Return:</comment>
  <info>QuickHashIntHash</info>  Returns a new <class>QuickHashIntHash</class>.


id: QuickHashIntHash::saveToFile
type: function
doc:
<comment>Description:</comment>
  This method stores an in-memory hash to disk
  
  This method stores an existing hash to a file on disk, in the same format that
  QuickHashIntHash::loadFromFile can read.

<comment>Param:</comment>
  <info>string</info>  <strong>$filename</strong>  The filename of the file to store the hash in.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: QuickHashIntHash::saveToString
type: function
doc:
<comment>Description:</comment>
  This method returns a serialized version of the hash
  
  This method returns a serialized version of the hash in the same format that
  QuickHashIntHash::loadFromString can read.

<comment>Return:</comment>
  <info>string</info>  This method returns a string containing a serialized format of the hash. Each element is
          stored as a four byte value in the Endianness that the current system uses.


id: QuickHashIntHash::set
type: function
doc:
<comment>Description:</comment>
  This method updates an entry in the hash with a new value, or
    adds a new one if the entry doesn't exist
  
  This method tries to update an entry with a new value. In case the entry did not yet exist, it
  will instead add a new entry. It returns whether the entry was added or update. If there are
  duplicate keys, only the first found element will get an updated value. Use
  <info>QuickHashIntHash::CHECK_FOR_DUPES</info> during hash creation to prevent duplicate keys from being part
  of the hash.

<comment>Param:</comment>
  <info>int</info>  <strong>$key</strong>    The key of the entry to add or update.
  <info>int</info>  <strong>$value</strong>  The new value to set the entry with.

<comment>Return:</comment>
  <info>bool</info>  2 if the entry was found and updated, 1 if the entry was newly added or 0 if there was an
        error.


id: QuickHashIntHash::update
type: function
doc:
<comment>Description:</comment>
  This method updates an entry in the hash with a new value
  
  This method updates an entry with a new value, and returns whether the entry was update. If there
  are duplicate keys, only the first found element will get an updated value. Use
  <info>QuickHashIntHash::CHECK_FOR_DUPES</info> during hash creation to prevent duplicate keys from being part
  of the hash.

<comment>Param:</comment>
  <info>int</info>  <strong>$key</strong>    The key of the entry to update.
  <info>int</info>  <strong>$value</strong>  The new value to update the entry with.

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> when the entry was found and updated, and <info>false</info> if the entry was not part of the hash
        already.


id: QuickHashIntSet
type: class
doc:
<comment>Description:</comment>
  This class wraps around a set containing integer numbers.
  
  Sets can also be iterated over with <return>foreach</return> as the Iterator interface is implemented as well. The
  order of which elements are returned in is not guaranteed.


id: QuickHashIntSet::CHECK_FOR_DUPES
type: constant
doc:
<comment>Description:</comment>
  If enabled, adding duplicate elements to a set (through either QuickHashIntSet::add or
  QuickHashIntSet::loadFromFile) will result in those elements to be dropped from the set. This will
  take up extra time, so only used when it is required.


id: QuickHashIntSet::__construct
type: function
doc:
<comment>Description:</comment>
  Creates a new QuickHashIntSet object
  
  This constructor creates a new <class>QuickHashIntSet</class>. The size is the amount of bucket lists to create.
  The more lists there are, the less collisions you will have. Options are also supported.

<comment>Param:</comment>
  <info>int</info>  <strong>$size</strong>     The amount of bucket lists to configure. The number you pass in will be
                 automatically rounded up to the next power of two. It is also automatically limited
                 from <return>4</return> to <return>4194304</return>.
  <info>int</info>  <strong>$options</strong>  The options that you can pass in are: <info>QuickHashIntSet::CHECK_FOR_DUPES</info>, which makes
                 sure no duplicate entries are added to the set;
                 <info>QuickHashIntSet::DO_NOT_USE_ZEND_ALLOC</info> to not use PHP's internal memory manager as
                 well as one of <info>QuickHashIntSet::HASHER_NO_HASH</info>, <info>QuickHashIntSet::HASHER_JENKINS1</info> or
                 <info>QuickHashIntSet::HASHER_JENKINS2</info>. These last three configure which hashing
                 algorithm to use. All options can be combined using bitmasks.

<comment>Return:</comment>
  <info>unknown</info>  Returns a new <class>QuickHashIntSet</class> object.


id: QuickHashIntSet::add
type: function
doc:
<comment>Description:</comment>
  This method adds a new entry to the set
  
  This method adds a new entry to the set, and returns whether the entry was added. Entries are by
  default always added unless <info>QuickHashIntSet::CHECK_FOR_DUPES</info> has been passed when the set was
  created.

<comment>Param:</comment>
  <info>int</info>  <strong>$key</strong>  The key of the entry to add.

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> when the entry was added, and <info>false</info> if the entry was not added.


id: QuickHashIntSet::delete
type: function
doc:
<comment>Description:</comment>
  This method deletes an entry from the set
  
  This method deletes an entry from the set, and returns whether the entry was deleted or not.
  Associated memory structures will not be freed immediately, but rather when the set itself is
  freed.

<comment>Param:</comment>
  <info>int</info>  <strong>$key</strong>  The key of the entry to delete.

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> when the entry was deleted, and <info>false</info> if the entry was not deleted.


id: QuickHashIntSet::exists
type: function
doc:
<comment>Description:</comment>
  This method checks whether a key is part of the set
  
  This method checks whether an entry with the provided key exists in the set.

<comment>Param:</comment>
  <info>int</info>  <strong>$key</strong>  The key of the entry to check for whether it exists in the set.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> when the entry was found, or <info>false</info> when the entry is not found.


id: QuickHashIntSet::getSize
type: function
doc:
<comment>Description:</comment>
  Returns the number of elements in the set
  
  Returns the number of elements in the set.

<comment>Return:</comment>
  <info>int</info>  The number of elements in the set.


id: QuickHashIntSet::loadFromFile
type: function
doc:
<comment>Description:</comment>
  This factory method creates a set from a file
  
  This factory method creates a new set from a definition file on disk. The file format consists of
  32 bit signed integers packed together in the Endianness that the system that the code runs on
  uses.

<comment>Param:</comment>
  <info>string</info>  <strong>$filename</strong>  The filename of the file to read the set from.
  <info>int</info>     <strong>$size</strong>      The amount of bucket lists to configure. The number you pass in will be
                     automatically rounded up to the next power of two. It is also automatically
                     limited from <return>4</return> to <return>4194304</return>.
  <info>int</info>     <strong>$options</strong>   The same options that the class' constructor takes; except that the size option
                     is ignored. It is automatically calculated to be the same as the number of
                     entries in the set, rounded up to the nearest power of two with a maximum limit
                     of <return>4194304</return>.

<comment>Return:</comment>
  <info>QuickHashIntSet</info>  Returns a new <class>QuickHashIntSet</class>.


id: QuickHashIntSet::loadFromString
type: function
doc:
<comment>Description:</comment>
  This factory method creates a set from a string
  
  This factory method creates a new set from a definition in a string. The file format consists of
  32 bit signed integers packed together in the Endianness that the system that the code runs on
  uses.

<comment>Param:</comment>
  <info>string</info>  <strong>$contents</strong>  The string containing a serialized format of the set.
  <info>int</info>     <strong>$size</strong>      The amount of bucket lists to configure. The number you pass in will be
                     automatically rounded up to the next power of two. It is also automatically
                     limited from <return>4</return> to <return>4194304</return>.
  <info>int</info>     <strong>$options</strong>   The same options that the class' constructor takes; except that the size option
                     is ignored. It is automatically calculated to be the same as the number of
                     entries in the set, rounded up to the nearest power of two automatically
                     limited from <return>64</return> to <return>4194304</return>.

<comment>Return:</comment>
  <info>QuickHashIntSet</info>  Returns a new <class>QuickHashIntSet</class>.


id: QuickHashIntSet::saveToFile
type: function
doc:
<comment>Description:</comment>
  This method stores an in-memory set to disk
  
  This method stores an existing set to a file on disk, in the same format that
  QuickHashIntSet::loadFromFile can read.

<comment>Param:</comment>
  <info>string</info>  <strong>$filename</strong>  The filename of the file to store the hash in.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: QuickHashIntSet::saveToString
type: function
doc:
<comment>Description:</comment>
  This method returns a serialized version of the set
  
  This method returns a serialized version of the set in the same format that
  QuickHashIntSet::loadFromString can read.

<comment>Return:</comment>
  <info>string</info>  This method returns a string containing a serialized format of the set. Each element is
          stored as a four byte value in the Endianness that the current system uses.


id: QuickHashIntStringHash
type: class
doc:
<comment>Description:</comment>
  This class wraps around a hash containing integer numbers, where the values are strings. Hashes
  are also available as implementation of the ArrayAccess interface.
  
  Hashes can also be iterated over with <return>foreach</return> as the Iterator interface is implemented as well.
  The order of which elements are returned in is not guaranteed.


id: QuickHashIntStringHash::CHECK_FOR_DUPES
type: constant
doc:
<comment>Description:</comment>
  If enabled, adding duplicate elements to a set (through either QuickHashIntStringHash::add or
  QuickHashIntStringHash::loadFromFile) will result in those elements to be dropped from the set.
  This will take up extra time, so only used when it is required.


id: QuickHashIntStringHash::__construct
type: function
doc:
<comment>Description:</comment>
  Creates a new QuickHashIntStringHash object
  
  This constructor creates a new <class>QuickHashIntStringHash</class>. The size is the amount of bucket lists to
  create. The more lists there are, the less collisions you will have. Options are also supported.

<comment>Param:</comment>
  <info>int</info>  <strong>$size</strong>     The amount of bucket lists to configure. The number you pass in will be
                 automatically rounded up to the next power of two. It is also automatically limited
                 from <return>64</return> to <return>4194304</return>.
  <info>int</info>  <strong>$options</strong>  The options that you can pass in are: <info>QuickHashIntStringHash::CHECK_FOR_DUPES</info>,
                 which makes sure no duplicate entries are added to the hash;
                 <info>QuickHashIntStringHash::DO_NOT_USE_ZEND_ALLOC</info> to not use PHP's internal memory
                 manager as well as one of <info>QuickHashIntStringHash::HASHER_NO_HASH</info>,
                 <info>QuickHashIntStringHash::HASHER_JENKINS1</info> or <info>QuickHashIntStringHash::HASHER_JENKINS2</info>.
                 These last three configure which hashing algorithm to use. All options can be
                 combined using bitmasks.

<comment>Return:</comment>
  <info>unknown</info>  Returns a new <class>QuickHashIntStringHash</class> object.


id: QuickHashIntStringHash::add
type: function
doc:
<comment>Description:</comment>
  This method adds a new entry to the hash
  
  This method adds a new entry to the hash, and returns whether the entry was added. Entries are by
  default always added unless <info>QuickHashIntStringHash::CHECK_FOR_DUPES</info> has been passed when the hash
  was created.

<comment>Param:</comment>
  <info>int</info>     <strong>$key</strong>    The key of the entry to add.
  <info>string</info>  <strong>$value</strong>  The value of the entry to add. If a non-string is passed, it will be converted to
                  a string automatically if possible.

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> when the entry was added, and <info>false</info> if the entry was not added.


id: QuickHashIntStringHash::get
type: function
doc:
<comment>Description:</comment>
  This method retrieves a value from the hash by its key
  
  This method retrieves a value from the hash by its key.

<comment>Param:</comment>
  <info>int</info>  <strong>$key</strong>  The key of the entry to retrieve.

<comment>Return:</comment>
  <info>mixed</info>  The value if the key exists, or <info>null</info> if the key wasn't part of the hash.


id: QuickHashIntStringHash::loadFromFile
type: function
doc:
<comment>Description:</comment>
  This factory method creates a hash from a file
  
  This factory method creates a new hash from a definition file on disk. The file format consists of
  a signature <return>'QH\0x12\0'</return>, the number of elements as a 32 bit signed integer in system Endianness,
  an unsigned 32 bit integer containing the number of element data to follow in characters. This
  element data contains all the strings. After the header and the strings, the elements follow in
  pairs of two unsigned 32 bit integers where the first one is the key, and the second one the index
  in the element data string. An example could be:
  
  QuickHash IntString file format
  
  QuickHash IntString file format

<comment>Param:</comment>
  <info>string</info>  <strong>$filename</strong>  The filename of the file to read the hash from.
  <info>int</info>     <strong>$size</strong>      The amount of bucket lists to configure. The number you pass in will be
                     automatically rounded up to the next power of two. It is also automatically
                     limited from <return>4</return> to <return>4194304</return>.
  <info>int</info>     <strong>$options</strong>   The same options that the class' constructor takes; except that the size option
                     is ignored. It is automatically calculated to be the same as the number of
                     entries in the hash, rounded up to the nearest power of two with a maximum
                     limit of <return>4194304</return>.

<comment>Return:</comment>
  <info>QuickHashIntStringHash</info>  Returns a new <class>QuickHashIntStringHash</class>.


id: QuickHashIntStringHash::loadFromString
type: function
doc:
<comment>Description:</comment>
  This factory method creates a hash from a string
  
  This factory method creates a new hash from a definition in a string. The format is the same as
  the one used in "loadFromFile".

<comment>Param:</comment>
  <info>string</info>  <strong>$contents</strong>  The string containing a serialized format of the hash.
  <info>int</info>     <strong>$size</strong>      The amount of bucket lists to configure. The number you pass in will be
                     automatically rounded up to the next power of two. It is also automatically
                     limited from 4 to 4194304.
  <info>int</info>     <strong>$options</strong>   The same options that the class' constructor takes; except that the size option
                     is ignored. It is automatically calculated to be the same as the number of
                     entries in the hash, rounded up to the nearest power of two with a maximum
                     limit of 4194304.

<comment>Return:</comment>
  <info>QuickHashIntStringHash</info>  Returns a new QuickHashIntStringHash.


id: QuickHashIntStringHash::saveToFile
type: function
doc:
<comment>Description:</comment>
  This method stores an in-memory hash to disk
  
  This method stores an existing hash to a file on disk, in the same format that loadFromFile() can
  read.

<comment>Param:</comment>
  <info>string</info>  <strong>$filename</strong>  The filename of the file to store the hash in.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: QuickHashIntStringHash::saveToString
type: function
doc:
<comment>Description:</comment>
  This method returns a serialized version of the hash
  
  This method returns a serialized version of the hash in the same format that
  QuickHashIntStringHash::loadFromString can read.

<comment>Return:</comment>
  <info>string</info>  This method returns a string containing a serialized format of the hash. Each element is
          stored as a four byte value in the Endianness that the current system uses.


id: QuickHashIntStringHash::set
type: function
doc:
<comment>Description:</comment>
  This method updates an entry in the hash with a new value, or
    adds a new one if the entry doesn't exist
  
  This method tries to update an entry with a new value. In case the entry did not yet exist, it
  will instead add a new entry. It returns whether the entry was added or update. If there are
  duplicate keys, only the first found element will get an updated value. Use
  QuickHashIntStringHash::CHECK_FOR_DUPES during hash creation to prevent duplicate keys from being
  part of the hash.

<comment>Param:</comment>
  <info>int</info>     <strong>$key</strong>    The key of the entry to add or update.
  <info>string</info>  <strong>$value</strong>  The value of the entry to add. If a non-string is passed, it will be converted to
                  a string automatically if possible.

<comment>Return:</comment>
  <info>int</info>  2 if the entry was found and updated, 1 if the entry was newly added or 0 if there was an
       error.


id: QuickHashIntStringHash::update
type: function
doc:
<comment>Description:</comment>
  This method updates an entry in the hash with a new value
  
  This method updates an entry with a new value, and returns whether the entry was update. If there
  are duplicate keys, only the first found element will get an updated value. Use
  QuickHashIntStringHash::CHECK_FOR_DUPES during hash creation to prevent duplicate keys from being
  part of the hash.

<comment>Param:</comment>
  <info>int</info>     <strong>$key</strong>    The key of the entry to update.
  <info>string</info>  <strong>$value</strong>  The new value for the entry. If a non-string is passed, it will be converted to a
                  string automatically if possible.

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> when the entry was found and updated, and <info>false</info> if the entry was not part of the hash
        already.


id: QuickHashStringIntHash
type: class
doc:
<comment>Description:</comment>
  This class wraps around a hash containing strings, where the values are integer numbers. Hashes
  are also available as implementation of the ArrayAccess interface.
  
  Hashes can also be iterated over with <return>foreach</return> as the Iterator interface is implemented as well.
  The order of which elements are returned in is not guaranteed.


id: QuickHashStringIntHash::CHECK_FOR_DUPES
type: constant
doc:
<comment>Description:</comment>
  If enabled, adding duplicate elements to a set (through either QuickHashStringIntHash::add or
  QuickHashStringIntHash::loadFromFile) will result in those elements to be dropped from the set.
  This will take up extra time, so only used when it is required.


id: QuickHashStringIntHash::__construct
type: function
doc:
<comment>Description:</comment>
  Creates a new QuickHashStringIntHash object
  
  This constructor creates a new <class>QuickHashStringIntHash</class>. The size is the amount of bucket lists to
  create. The more lists there are, the less collisions you will have. Options are also supported.

<comment>Param:</comment>
  <info>int</info>  <strong>$size</strong>     The amount of bucket lists to configure. The number you pass in will be
                 automatically rounded up to the next power of two. It is also automatically limited
                 from <return>64</return> to <return>4194304</return>.
  <info>int</info>  <strong>$options</strong>  The options that you can pass in are: <info>QuickHashStringIntHash::CHECK_FOR_DUPES</info>,
                 which makes sure no duplicate entries are added to the hash and
                 <info>QuickHashStringIntHash::DO_NOT_USE_ZEND_ALLOC</info> to not use PHP's internal memory
                 manager.

<comment>Return:</comment>
  <info>unknown</info>  Returns a new <class>QuickHashStringIntHash</class> object.


id: QuickHashStringIntHash::add
type: function
doc:
<comment>Description:</comment>
  This method adds a new entry to the hash
  
  This method adds a new entry to the hash, and returns whether the entry was added. Entries are by
  default always added unless <info>QuickHashStringIntHash::CHECK_FOR_DUPES</info> has been passed when the hash
  was created.

<comment>Param:</comment>
  <info>string</info>  <strong>$key</strong>    The key of the entry to add.
  <info>int</info>     <strong>$value</strong>  The value of the entry to add.

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> when the entry was added, and <info>false</info> if the entry was not added.


id: QuickHashStringIntHash::delete
type: function
doc:
<comment>Description:</comment>
  This method deletes an entry from the hash
  
  This method deletes an entry from the hash, and returns whether the entry was deleted or not.
  Associated memory structures will not be freed immediately, but rather when the hash itself is
  freed.
  
  Elements can not be deleted when the hash is used in an iterator. The method will not throw an
  exception, but simply return <info>false</info> like would happen with any other deletion failure.

<comment>Param:</comment>
  <info>string</info>  <strong>$key</strong>  The key of the entry to delete.

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> when the entry was deleted, and <info>false</info> if the entry was not deleted.


id: QuickHashStringIntHash::exists
type: function
doc:
<comment>Description:</comment>
  This method checks whether a key is part of the hash
  
  This method checks whether an entry with the provided key exists in the hash.

<comment>Param:</comment>
  <info>string</info>  <strong>$key</strong>  The key of the entry to check for whether it exists in the hash.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> when the entry was found, or <info>false</info> when the entry is not found.


id: QuickHashStringIntHash::get
type: function
doc:
<comment>Description:</comment>
  This method retrieves a value from the hash by its key
  
  This method retrieves a value from the hash by its key.

<comment>Param:</comment>
  <info>string</info>  <strong>$key</strong>  The key of the entry to retrieve.

<comment>Return:</comment>
  <info>mixed</info>  The value if the key exists, or <info>null</info> if the key wasn't part of the hash.


id: QuickHashStringIntHash::loadFromFile
type: function
doc:
<comment>Description:</comment>
  This factory method creates a hash from a file
  
  This factory method creates a new hash from a definition file on disk. The file format consists of
  a signature <return>'QH\0x21\0'</return>, the number of elements as a 32 bit signed integer in system Endianness,
  an unsigned 32 bit integer containing the number of element data to follow in characters. This
  element data contains all the strings. The follows another signed 32 bit integer containing the
  number of bucket lists.  After the header and the strings, the elements follow. They are ordered
  by bucket list so that the keys don't have to be hashed in order to restore the hash. For each
  bucket list, the following information is stored (all as 32 bit integers): the bucket list index,
  the number of elements in that list, and then in pairs of two unsigned 32 bit integers the
  elements, where the first one is the index into the string list containing the keys, and the
  second one the value.  An example could be:
  
  QuickHash StringIntHash file format
  
  QuickHash IntHash file format

<comment>Param:</comment>
  <info>string</info>  <strong>$filename</strong>  The filename of the file to read the hash from.
  <info>int</info>     <strong>$size</strong>      The amount of bucket lists to configure. The number you pass in will be
                     automatically rounded up to the next power of two. It is also automatically
                     limited from <return>4</return> to <return>4194304</return>.
  <info>int</info>     <strong>$options</strong>   The same options that the class' constructor takes; except that the size option
                     is ignored. It is read from the file format (unlike the <class>QuickHashIntHash</class> and
                     <class>QuickHashIntStringHash</class> classes, where it is automatically calculated from the
                     number of entries in the hash.)

<comment>Return:</comment>
  <info>QuickHashStringIntHash</info>  Returns a new <class>QuickHashStringIntHash</class>.


id: QuickHashStringIntHash::loadFromString
type: function
doc:
<comment>Description:</comment>
  This factory method creates a hash from a string
  
  This factory method creates a new hash from a definition in a string. The format is the same as
  the one used in "loadFromFile".

<comment>Param:</comment>
  <info>string</info>  <strong>$contents</strong>  The string containing a serialized format of the hash.
  <info>int</info>     <strong>$size</strong>      The amount of bucket lists to configure. The number you pass in will be
                     automatically rounded up to the next power of two. It is also automatically
                     limited from 4 to 4194304.
  <info>int</info>     <strong>$options</strong>   The same options that the class' constructor takes; except that the size option
                     is ignored. It is automatically calculated to be the same as the number of
                     entries in the hash, rounded up to the nearest power of two with a maximum
                     limit of 4194304.

<comment>Return:</comment>
  <info>QuickHashStringIntHash</info>  Returns a new QuickHashStringIntHash.


id: QuickHashStringIntHash::saveToString
type: function
doc:
<comment>Description:</comment>
  This method returns a serialized version of the hash
  
  This method returns a serialized version of the hash in the same format that
  QuickHashStringIntHash::loadFromString can read.

<comment>Return:</comment>
  <info>string</info>  This method returns a serialized format of an existing hash, in the same format that
          QuickHashStringIntHash::loadFromString can read.


id: QuickHashStringIntHash::set
type: function
doc:
<comment>Description:</comment>
  This method updates an entry in the hash with a new value, or
    adds a new one if the entry doesn't exist
  
  This method tries to update an entry with a new value. In case the entry did not yet exist, it
  will instead add a new entry. It returns whether the entry was added or update. If there are
  duplicate keys, only the first found element will get an updated value. Use
  QuickHashStringIntHash::CHECK_FOR_DUPES during hash creation to prevent duplicate keys from being
  part of the hash.

<comment>Param:</comment>
  <info>string</info>  <strong>$key</strong>    The key of the entry to add or update.
  <info>int</info>     <strong>$value</strong>  The value of the entry to add. If a non-string is passed, it will be converted to
                  a string automatically if possible.

<comment>Return:</comment>
  <info>int</info>  2 if the entry was found and updated, 1 if the entry was newly added or 0 if there was an
       error.


id: QuickHashStringIntHash::update
type: function
doc:
<comment>Description:</comment>
  This method updates an entry in the hash with a new value
  
  This method updates an entry with a new value, and returns whether the entry was update. If there
  are duplicate keys, only the first found element will get an updated value. Use
  QuickHashStringIntHash::CHECK_FOR_DUPES during hash creation to prevent duplicate keys from being
  part of the hash.

<comment>Param:</comment>
  <info>string</info>  <strong>$key</strong>    The key of the entry to update.
  <info>int</info>     <strong>$value</strong>  The new value for the entry. If a non-string is passed, it will be converted to a
                  string automatically if possible.

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> when the entry was found and updated, and <info>false</info> if the entry was not part of the hash
        already.


id: RADIUS_ACCESS_ACCEPT
type: constant
doc:
<comment>Description:</comment>
  An Access-Accept response to an Access-Request indicating that the RADIUS server authenticated the
  user successfully.


id: RADIUS_ACCESS_CHALLENGE
type: constant
doc:
<comment>Description:</comment>
  An Access-Challenge response to an Access-Request indicating that the RADIUS server requires
  further information in another Access-Request before authenticating the user.


id: RADIUS_ACCESS_REJECT
type: constant
doc:
<comment>Description:</comment>
  An Access-Reject response to an Access-Request indicating that the RADIUS server could not
  authenticate the user.


id: RADIUS_ACCESS_REQUEST
type: constant
doc:
<comment>Description:</comment>
  An Access-Request, used to authenticate a user against a RADIUS server. Access request packets
  must include a <info>RADIUS_NAS_IP_ADDRESS</info> or a <info>RADIUS_NAS_IDENTIFIER</info> attribute, must also include a
  <info>RADIUS_USER_PASSWORD</info>, <info>RADIUS_CHAP_PASSWORD</info> or a <info>RADIUS_STATE</info> attribute, and should include a
  <info>RADIUS_USER_NAME</info> attribute.


id: RADIUS_ACCOUNTING_REQUEST
type: constant
doc:
<comment>Description:</comment>
  An Accounting-Request, used to convey accounting information for a service to the RADIUS server.


id: RADIUS_ACCT_AUTHENTIC
type: constant
doc:
<comment>Description:</comment>
  Accounting authentic, one of: <info>RADIUS_AUTH_RADIUS</info><info>RADIUS_AUTH_LOCAL</info><info>RADIUS_AUTH_REMOTE</info>


id: RADIUS_ACCT_STATUS_TYPE
type: constant
doc:
<comment>Description:</comment>
  Accounting status type, one of: <info>RADIUS_START</info><info>RADIUS_STOP</info><info>RADIUS_ACCOUNTING_ON</info><info>RADIUS_ACCOUNTING_OFF</info>


id: RADIUS_ACCT_TERMINATE_CAUSE
type: constant
doc:
<comment>Description:</comment>
  Accounting terminate cause, one of:
  <info>RADIUS_TERM_USER_REQUEST</info><info>RADIUS_TERM_LOST_CARRIER</info><info>RADIUS_TERM_LOST_SERVICE</info><info>RADIUS_TERM_IDLE_TIMEOUT</info><info>RADIUS_TERM_SESSION_TIMEOUT</info><info>RADIUS_TERM_ADMIN_RESET</info><info>RADIUS_TERM_ADMIN_REBOOT</info><info>RADIUS_TERM_PORT_ERROR</info><info>RADIUS_TERM_NAS_ERROR</info><info>RADIUS_TERM_NAS_REQUEST</info><info>RADIUS_TERM_NAS_REBOOT</info><info>RADIUS_TERM_PORT_UNNEEDED</info><info>RADIUS_TERM_PORT_PREEMPTED</info><info>RADIUS_TERM_PORT_SUSPENDED</info><info>RADIUS_TERM_SERVICE_UNAVAILABLE</info><info>RADIUS_TERM_CALLBACK</info><info>RADIUS_TERM_USER_ERROR</info><info>RADIUS_TERM_HOST_REQUEST</info>


id: RADIUS_CALLBACK_ID
type: constant
doc:
<comment>Description:</comment>
  The Callback-Id attribute. The attribute value is a <info>string</info> containing an implementation-specific
  name of the place to be called.


id: RADIUS_CALLBACK_NUMBER
type: constant
doc:
<comment>Description:</comment>
  The Callback-Number attribute. The attribute value is a <info>string</info> containing the dialing string to
  use for callback.


id: RADIUS_CHAP_PASSWORD
type: constant
doc:
<comment>Description:</comment>
  The Chap-Password attribute. The attribute value is expected to be a <info>string</info> with the first byte
  containing the CHAP identifier, and the subsequent 16 bytes containing the MD5 hash of the CHAP
  identifier, the plaintext password and the CHAP challenge value concatenated together. Note that
  the CHAP challenge value should also be sent separately in a <info>RADIUS_CHAP_CHALLENGE</info> attribute.
  
  Using CHAP passwords


id: RADIUS_CLASS
type: constant
doc:
<comment>Description:</comment>
  The Class attribute. The attribute value is an arbitrary <info>string</info> included in an Access-Accept
  message that should then be sent to the accounting server in Accounting-Request messages, and can
  be set using <strong>radius_put_attr()</strong>.


id: RADIUS_COA_ACK
type: constant
doc:
<comment>Description:</comment>
  A CoA-ACK, sent to the RADIUS server to indicate that the user authorisations have been updated.
  
  This constant is available in PECL radius 1.3.0 and later.


id: RADIUS_COA_NAK
type: constant
doc:
<comment>Description:</comment>
  A CoA-NAK, sent to the RADIUS server to indicate that the user authorisations could not be
  updated.
  
  This constant is available in PECL radius 1.3.0 and later.


id: RADIUS_COA_REQUEST
type: constant
doc:
<comment>Description:</comment>
  A CoA-Request, sent from the RADIUS server to indicate that the authorisations within the user
  session have changed. A response must be sent in the form of a CoA-ACK or a CoA-NAK.
  
  This constant is available in PECL radius 1.3.0 and later.


id: RADIUS_DISCONNECT_ACK
type: constant
doc:
<comment>Description:</comment>
  A Disconnect-ACK, sent to the RADIUS server to indicate that the user session has been terminated.
  
  This constant is available in PECL radius 1.3.0 and later.


id: RADIUS_DISCONNECT_NAK
type: constant
doc:
<comment>Description:</comment>
  A Disconnect-NAK, sent to the RADIUS server to indicate that the user session could not be
  terminated.
  
  This constant is available in PECL radius 1.3.0 and later.


id: RADIUS_DISCONNECT_REQUEST
type: constant
doc:
<comment>Description:</comment>
  A Disconnect-Request, sent from the RADIUS server to indicate that the user session must be
  terminated.
  
  This constant is available in PECL radius 1.3.0 and later.


id: RADIUS_FILTER_ID
type: constant
doc:
<comment>Description:</comment>
  The Filter-ID attribute. The attribute value is expected to be an implementation-specific,
  human-readable <info>string</info> of filters, which can be set using <strong>radius_put_attr()</strong>.


id: RADIUS_FRAMED_COMPRESSION
type: constant
doc:
<comment>Description:</comment>
  The Framed-Compression attribute. The attribute value is expected to be an <info>int</info> indicating the
  compression protocol to be used, and can be set using <strong>radius_put_int()</strong>. Possible values include
  these constants: <info>RADIUS_COMP_NONE</info>: No compression<info>RADIUS_COMP_VJ</info>: VJ TCP/IP header
  compression<info>RADIUS_COMP_IPXHDR</info>: IPX header compression<info>RADIUS_COMP_STAC_LZS</info>: Stac-LZS compression
  (added in PECL radius 1.3.0b2)


id: RADIUS_FRAMED_IPX_NETWORK
type: constant
doc:
<comment>Description:</comment>
  The Framed-IPX-Network attribute. The attribute value is an <info>int</info> containing the IPX network to be
  configured for the user, or <return>0xFFFFFFFE</return> to indicate that the RADIUS client should select the
  network, and can be accessed via <strong>radius_cvt_int()</strong>.


id: RADIUS_FRAMED_IP_ADDRESS
type: constant
doc:
<comment>Description:</comment>
  The Framed-IP-Address attribute. The attribute value is expected to be the address of the user's
  network encoded as an <info>int</info>, which can be set using <strong>radius_put_addr()</strong> and retrieved using
  <strong>radius_cvt_addr()</strong>.


id: RADIUS_FRAMED_IP_NETMASK
type: constant
doc:
<comment>Description:</comment>
  The Framed-IP-Netmask attribute. The attribute value is expected to be the netmask of the user's
  network encoded as an <info>int</info>, which can be set using <strong>radius_put_addr()</strong> and retrieved using
  <strong>radius_cvt_addr()</strong>.


id: RADIUS_FRAMED_MTU
type: constant
doc:
<comment>Description:</comment>
  The Framed-MTU attribute. The attribute value is expected to be an <info>int</info> indicating the MTU to be
  configured for the user, and can be set using <strong>radius_put_int()</strong>.


id: RADIUS_FRAMED_PROTOCOL
type: constant
doc:
<comment>Description:</comment>
  The Framed-Protocol attribute. The attribute value is expected to be an <info>int</info> indicating the framing
  to be used for framed access, and can be set using <strong>radius_put_int()</strong>. The possible attribute values
  include these constants: <info>RADIUS_PPP</info><info>RADIUS_SLIP</info><info>RADIUS_ARAP</info><info>RADIUS_GANDALF</info><info>RADIUS_XYLOGICS</info>


id: RADIUS_FRAMED_ROUTE
type: constant
doc:
<comment>Description:</comment>
  The Framed-Route attribute. The attribute value is a <info>string</info> containing an implementation-specific
  set of routes to be configured for the user.


id: RADIUS_FRAMED_ROUTING
type: constant
doc:
<comment>Description:</comment>
  The Framed-Routing attribute. The attribute value is expected to be an <info>int</info> indicating the routing
  method for the user, which can be set using <strong>radius_put_int()</strong>.
  
  Possible values include: <return>0</return>: No routing<return>1</return>: Send routing packets<return>2</return>: Listen for routing packets<return>3</return>: Send
  and listen


id: RADIUS_LOGIN_IP_HOST
type: constant
doc:
<comment>Description:</comment>
  The Login-IP-Host attribute. The attribute value is expected to the IP address to connect the user
  to, encoded as an <info>int</info>, which can be set using <strong>radius_put_addr()</strong>.


id: RADIUS_LOGIN_SERVICE
type: constant
doc:
<comment>Description:</comment>
  The Login-Service attribute. The attribute value is an <info>int</info> indicating the service to connect the
  user to on the login host. The value can be converted to a PHP integer via <strong>radius_cvt_int()</strong>.


id: RADIUS_LOGIN_TCP_PORT
type: constant
doc:
<comment>Description:</comment>
  The Login-TCP-Port attribute. The attribute value is an <info>int</info> indicating the port to connect the
  user to on the login host. The value can be converted to a PHP integer via <strong>radius_cvt_int()</strong>.


id: RADIUS_NAS_IP_ADDRESS
type: constant
doc:
<comment>Description:</comment>
  The NAS-IP-Address attribute. The attribute value is expected to the IP address of the RADIUS
  client encoded as an <info>int</info>, which can be set using <strong>radius_put_addr()</strong>.


id: RADIUS_NAS_PORT
type: constant
doc:
<comment>Description:</comment>
  The NAS-Port attribute. The attribute value is expected to be the physical port of the user on the
  RADIUS client encoded as an <info>int</info>, which can be set using <strong>radius_put_int()</strong>.


id: RADIUS_NAS_PORT_TYPE
type: constant
doc:
<comment>Description:</comment>
  NAS port type, one of:
  <info>RADIUS_ASYNC</info><info>RADIUS_SYNC</info><info>RADIUS_ISDN_SYNC</info><info>RADIUS_ISDN_ASYNC_V120</info><info>RADIUS_ISDN_ASYNC_V110</info><info>RADIUS_VIRTUAL</info><info>RADIUS_PIAFS</info><info>RADIUS_HDLC_CLEAR_CHANNEL</info><info>RADIUS_X_25</info><info>RADIUS_X_75</info><info>RADIUS_G_3_FAX</info><info>RADIUS_SDSL</info><info>RADIUS_ADSL_CAP</info><info>RADIUS_ADSL_DMT</info><info>RADIUS_IDSL</info><info>RADIUS_ETHERNET</info><info>RADIUS_XDSL</info><info>RADIUS_CABLE</info><info>RADIUS_WIRELESS_OTHER</info><info>RADIUS_WIRELESS_IEEE_802_11</info>


id: RADIUS_OPTION_SALT
type: constant
doc:
<comment>Description:</comment>
  When set, this option will result in the attribute value being salt-encrypted.


id: RADIUS_OPTION_TAGGED
type: constant
doc:
<comment>Description:</comment>
  When set, this option will result in the attribute value being tagged with the value of the tag
  parameter.


id: RADIUS_REPLY_MESSAGE
type: constant
doc:
<comment>Description:</comment>
  The Reply-Message attribute. The attribute value is a <info>string</info> containing text that may be displayed
  to the user in response to an access request.


id: RADIUS_SERVICE_TYPE
type: constant
doc:
<comment>Description:</comment>
  The Service-Type attribute. The attribute value indicates the service type the user is requesting,
  and is expected to be an <info>int</info>, which can be set using <strong>radius_put_int()</strong>.
  
  A number of constants are provided to represent the possible values of this attribute. They
  include:
  <info>RADIUS_LOGIN</info><info>RADIUS_FRAMED</info><info>RADIUS_CALLBACK_LOGIN</info><info>RADIUS_CALLBACK_FRAMED</info><info>RADIUS_OUTBOUND</info><info>RADIUS_ADMINISTRATIVE</info><info>RADIUS_NAS_PROMPT</info><info>RADIUS_AUTHENTICATE_ONLY</info><info>RADIUS_CALLBACK_NAS_PROMPT</info>


id: RADIUS_STATE
type: constant
doc:
<comment>Description:</comment>
  The State attribute. The attribute value is an implementation-defined <info>string</info> included in an
  Access-Challenge from a server that must be included in the subsequent Access-Request, and can be
  set using <strong>radius_put_attr()</strong>.


id: RADIUS_USER_NAME
type: constant
doc:
<comment>Description:</comment>
  The User-Name attribute. The attribute value is expected to be a <info>string</info> containing the name of the
  user being authenticated, and can be set using <strong>radius_put_attr()</strong>.


id: RADIUS_USER_PASSWORD
type: constant
doc:
<comment>Description:</comment>
  The User-Password attribute. The attribute value is expected to be a <info>string</info> containing the user's
  password, and can be set using <strong>radius_put_attr()</strong>. This value will be obfuscated on transmission as
  described in section 5.2 of RFC 2865.


id: RADIUS_VENDOR_MICROSOFT
type: constant
doc:
<comment>Description:</comment>
  Microsoft specific vendor attributes (RFC 2548), one of:
  <info>RADIUS_MICROSOFT_MS_CHAP_RESPONSE</info><info>RADIUS_MICROSOFT_MS_CHAP_ERROR</info><info>RADIUS_MICROSOFT_MS_CHAP_PW_1</info><info>RADIUS_MICROSOFT_MS_CHAP_PW_2</info><info>RADIUS_MICROSOFT_MS_CHAP_LM_ENC_PW</info><info>RADIUS_MICROSOFT_MS_CHAP_NT_ENC_PW</info><info>RADIUS_MICROSOFT_MS_MPPE_ENCRYPTION_POLICY</info><info>RADIUS_MICROSOFT_MS_MPPE_ENCRYPTION_TYPES</info><info>RADIUS_MICROSOFT_MS_RAS_VENDOR</info><info>RADIUS_MICROSOFT_MS_CHAP_DOMAIN</info><info>RADIUS_MICROSOFT_MS_CHAP_CHALLENGE</info><info>RADIUS_MICROSOFT_MS_CHAP_MPPE_KEYS</info><info>RADIUS_MICROSOFT_MS_BAP_USAGE</info><info>RADIUS_MICROSOFT_MS_LINK_UTILIZATION_THRESHOLD</info><info>RADIUS_MICROSOFT_MS_LINK_DROP_TIME_LIMIT</info><info>RADIUS_MICROSOFT_MS_MPPE_SEND_KEY</info><info>RADIUS_MICROSOFT_MS_MPPE_RECV_KEY</info><info>RADIUS_MICROSOFT_MS_RAS_VERSION</info><info>RADIUS_MICROSOFT_MS_OLD_ARAP_PASSWORD</info><info>RADIUS_MICROSOFT_MS_NEW_ARAP_PASSWORD</info><info>RADIUS_MICROSOFT_MS_ARAP_PASSWORD_CHANGE_REASON</info><info>RADIUS_MICROSOFT_MS_FILTER</info><info>RADIUS_MICROSOFT_MS_ACCT_AUTH_TYPE</info><info>RADIUS_MICROSOFT_MS_ACCT_EAP_TYPE</info><info>RADIUS_MICROSOFT_MS_CHAP2_RESPONSE</info><info>RADIUS_MICROSOFT_MS_CHAP2_SUCCESS</info><info>RADIUS_MICROSOFT_MS_CHAP2_PW</info><info>RADIUS_MICROSOFT_MS_PRIMARY_DNS_SERVER</info><info>RADIUS_MICROSOFT_MS_SECONDARY_DNS_SERVER</info><info>RADIUS_MICROSOFT_MS_PRIMARY_NBNS_SERVER</info><info>RADIUS_MICROSOFT_MS_SECONDARY_NBNS_SERVER</info><info>RADIUS_MICROSOFT_MS_ARAP_CHALLENGE</info>


id: RADIUS_VENDOR_SPECIFIC
type: constant
doc:
<comment>Description:</comment>
  The Vendor-Specific attribute. In general, vendor attribute values should be set using
  <strong>radius_put_vendor_addr()</strong>, <strong>radius_put_vendor_attr()</strong>, <strong>radius_put_vendor_int()</strong> and
  <strong>radius_put_vendor_string()</strong>, rather than directly.
  
  This constant is mostly useful when interpreting vendor specific attributes in responses from a
  RADIUS server; when a vendor specific attribute is received, the <strong>radius_get_vendor_attr()</strong> function
  should be used to access the vendor ID, attribute type and attribute value.


id: READLINE_LIB
type: constant
doc:
<comment>Description:</comment>
  The library which is used for readline support; currently either <return>readline</return> or <return>libedit</return>.


id: RNP_ENCRYPT_NOWRAP
type: constant
doc:
<comment>Description:</comment>
  Allows encryption of signed message. Message is not wrapped into literal data packet.


id: RNP_KEYSTORE_KBX
type: constant
doc:
<comment>Description:</comment>
  Keystore format "KBX". For public keys only. A keybox is a file format used to store public keys
  along with meta information and indices.


id: RNP_KEY_EXPORT_SUBKEYS
type: constant
doc:
<comment>Description:</comment>
  If primary key is being exported, all subkeys will be exported too.


id: RNP_KEY_REMOVE_SUBKEYS
type: constant
doc:
<comment>Description:</comment>
  If primary key is being deleted, all of its subkeys will be removed too.


id: RNP_LOAD_SAVE_PERMISSIVE
type: constant
doc:
<comment>Description:</comment>
  Allows to ignore bad signature/key/subkey packets during key import.


id: RNP_LOAD_SAVE_PUBLIC_KEYS
type: constant
doc:
<comment>Description:</comment>
  Load or save public keys only. Can be OR-ed with <info>RNP_LOAD_SAVE_SECRET_KEYS</info> to load both public and
  private keys to the FFI context or save them from the context.


id: RNP_LOAD_SAVE_SECRET_KEYS
type: constant
doc:
<comment>Description:</comment>
  Load or save secret keys only. Can be OR-ed with <info>RNP_LOAD_SAVE_PUBLIC_KEYS</info> to load both public and
  private keys to the FFI context or save them from the context.


id: RPMMIRE_DEFAULT
type: constant
doc:
<comment>Description:</comment>
  Search pattern is a regular expression with \., .* and ^...$ added.


id: RPMTAG_ENHANCENAME
type: constant
doc:
<comment>Description:</comment>
  Weak dependencies, with database index, requires librpm &gt;= 4.13.


id: RPMTAG_FILETRIGGERNAME
type: constant
doc:
<comment>Description:</comment>
  File trigger name, with database index, requires librpm &gt;= 4.13.


id: RPMTAG_RECOMMENDNAME
type: constant
doc:
<comment>Description:</comment>
  Recommended weak dependencies, with database index, requires librpm &gt;= 4.13.


id: RPMTAG_SUGGESTNAME
type: constant
doc:
<comment>Description:</comment>
  Suggested weak dependencies, with database index, requires librpm &gt;= 4.13.


id: RPMTAG_TRANSFILETRIGGERNAME
type: constant
doc:
<comment>Description:</comment>
  Transaction file trigger name, with database index, requires librpm &gt;= 4.13.


id: RRDCreator::__construct
type: function
doc:
<comment>Description:</comment>
  Creates new RRDCreator instance
  
  Creates new <class>RRDCreator</class> instance.

<comment>Param:</comment>
  <info>string</info>  <strong>$path</strong>       Path for newly created RRD database file.
  <info>string</info>  <strong>$startTime</strong>  Time for the first value in RRD database. Parameter supports all formats which
                      are supported by rrd create call.
  <info>int</info>     <strong>$step</strong>       Base interval in seconds with which data will be fed into the RRD database.


id: RRDCreator::addArchive
type: function
doc:
<comment>Description:</comment>
  Adds RRA - archive of data values for each data source
  
  Adds RRA definition by description of archive. Archive consists  of a number of data values or
  statistics for each of the defined data-sources (DS). Data sources are defined by method
  RRDCreator::addDataSource. You need call this method for each requested archive.

<comment>Param:</comment>
  <info>string</info>  <strong>$description</strong>  Definition of archive - RRA. This has same format as RRA definition in rrd
                        create command. See man page of rrd create for more details.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: RRDCreator::addDataSource
type: function
doc:
<comment>Description:</comment>
  Adds data source definition for RRD database
  
  RRD can accept input from several data sources (DS), e.g incoming and outgoing traffic. This
  method adds data source by description. You need call this method for each data source.

<comment>Param:</comment>
  <info>string</info>  <strong>$description</strong>  Definition of data source - DS. This has same format as DS definition in rrd
                        create command. See man page of rrd create for more details.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: RRDCreator::save
type: function
doc:
<comment>Description:</comment>
  Saves the RRD database to a file
  
  Saves the RRD database into file, which name is defined by RRDCreator::__construct.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.


id: RRDGraph::__construct
type: function
doc:
<comment>Description:</comment>
  Creates new RRDGraph instance
  
  Creates new <class>RRDGraph</class> instance. This instance is responsible for rendering the result of RRD
  database query into image.

<comment>Param:</comment>
  <info>string</info>  <strong>$path</strong>  Full path for the newly created image.


id: RRDGraph::save
type: function
doc:
<comment>Description:</comment>
  Saves the result of query into image
  
  Saves the result of RRD database query into image defined by RRDGraph::__construct.

<comment>Return:</comment>
  <info>array</info>  Returns array with information about generated image, or <info>false</info> on failure.


id: RRDGraph::saveVerbose
type: function
doc:
<comment>Description:</comment>
  Saves the RRD database query into image and returns the verbose
     information about generated graph
    
  
  Saves the RRD database query into image file defined by method RRDGraph::__construct and returns
  the verbose information about generated graph, if "-" is used as image filename, image data are
  also returned in result array.

<comment>Return:</comment>
  <info>array</info>  Returns array with detailed information about generated image, or <info>false</info> on failure.


id: RRDGraph::setOptions
type: function
doc:
<comment>Description:</comment>
  Sets the options for rrd graph export

<comment>Param:</comment>
  <info>array</info>  <strong>$options</strong>  List of options for the image generation from the RRD database file. It can be
                   list of strings or list of strings with keys for better readability. Read the rrd
                   graph man pages for list of available options.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: RRDUpdater::__construct
type: function
doc:
<comment>Description:</comment>
  Creates new RRDUpdater instance
  
  Creates new RRDUpdater instance. This instance is responsible for updating the RRD database file.

<comment>Param:</comment>
  <info>string</info>  <strong>$path</strong>  Filesystem path for RRD database file, which will be updated.


id: RRDUpdater::update
type: function
doc:
<comment>Description:</comment>
  Update the RRD database file
  
  Updates the RRD file defined via RRDUpdater::__construct. The file is updated with a specific
  values.

<comment>Param:</comment>
  <info>array</info>   <strong>$values</strong>  Data for update. Key is data source name.
  <info>string</info>  <strong>$time</strong>    Time value for updating the RRD with a particular data. Default value is current
                   time.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.


id: RUNKIT7_ACC_PRIVATE
type: constant
doc:
<comment>Description:</comment>
  Flag for <strong>runkit7_method_add()</strong> and <strong>runkit7_method_redefine()</strong> to make the method private.


id: RUNKIT7_ACC_PROTECTED
type: constant
doc:
<comment>Description:</comment>
  Flag for <strong>runkit7_method_add()</strong> and <strong>runkit7_method_redefine()</strong> to make the method protected.


id: RUNKIT7_ACC_PUBLIC
type: constant
doc:
<comment>Description:</comment>
  Flag for <strong>runkit7_method_add()</strong> and <strong>runkit7_method_redefine()</strong> to make the method public.


id: RUNKIT7_ACC_RETURN_REFERENCE
type: constant
doc:
<comment>Description:</comment>
  Include this flag to make the function or method being created or redeclared return a reference.


id: RUNKIT7_ACC_STATIC
type: constant
doc:
<comment>Description:</comment>
  Flag for <strong>runkit7_method_add()</strong> and <strong>runkit7_method_redefine()</strong> to make the method static.


id: RUNKIT7_FEATURE_SANDBOX
type: constant
doc:
<comment>Description:</comment>
  Always 0, it's impractical to implement the sandbox feature in php 7.


id: RUNKIT7_IMPORT_CLASSES
type: constant
doc:
<comment>Description:</comment>
  <strong>runkit7_import()</strong> flag representing a bitwise OR of the <info>RUNKIT7_IMPORT_CLASS_*</info> constants.


id: RUNKIT7_IMPORT_CLASS_CONSTS
type: constant
doc:
<comment>Description:</comment>
  <strong>runkit7_import()</strong> flag indicating that class constants should be imported from the specified file.


id: RUNKIT7_IMPORT_CLASS_METHODS
type: constant
doc:
<comment>Description:</comment>
  <strong>runkit7_import()</strong> flag indicating that class methods should be imported from the specified file.


id: RUNKIT7_IMPORT_CLASS_PROPS
type: constant
doc:
<comment>Description:</comment>
  <strong>runkit7_import()</strong> flag indicating that class standard properties should be imported from the
  specified file.


id: RUNKIT7_IMPORT_CLASS_STATIC_PROPS
type: constant
doc:
<comment>Description:</comment>
  <strong>runkit7_import()</strong> flag indicating that class static properties should be imported from the
  specified file. Available since Runkit 1.0.1.


id: RUNKIT7_IMPORT_FUNCTIONS
type: constant
doc:
<comment>Description:</comment>
  <strong>runkit7_import()</strong> flag indicating that normal functions should be imported from the specified file.


id: RUNKIT7_IMPORT_OVERRIDE
type: constant
doc:
<comment>Description:</comment>
  <strong>runkit7_import()</strong> flag indicating that if any of the imported functions, methods, constants, or
  properties already exist, they should be replaced with the new definitions.  If this flag is not
  set, then any imported definitions which already exist will be discarded.


id: Random\CryptoSafeEngine
type: class
doc:
<comment>Description:</comment>
  A marker interface indicating that the <info>Random\Engine</info> returns cryptographically secure randomness.


id: Random\Engine
type: class
doc:
<comment>Description:</comment>
  A <class>Random\Engine</class> provides a low-level source of randomness by returning random bytes that are
  consumed by high-level APIs to perform their operations. The <class>Random\Engine</class> interface allows
  swapping out the algorithm used to generate randomness, because each algorithm makes different
  tradeoffs to fit specific use-cases. Some algorithms are very fast, but generate lower-quality
  randomness, whereas other algorithms are slower, but generate better randomness, up to
  cryptographically secure randomness as provided by the <class>Random\Engine\Secure</class> engine.
  
  PHP provides several <class>Random\Engine</class>s out of the box to accomodate different use-cases. The
  <class>Random\Engine\Secure</class> engine that is backed by a CSPRNG is the recommended safe default choice,
  unless the application requires either reproducible sequences or very high performance.


id: Random\Engine::generate
type: function
doc:
<comment>Description:</comment>
  Generates randomness
  
  Returns randomness and advances the algorithm’s state by one step.
  
  The randomness is represented by a binary string containing random bytes. This representation
  allows to unambiguously interpret the random bits generated by the algorithm, for example to
  accomodate different output sizes used by different algorithms.
  
  Algorithms that natively operate on integer values should return the integer in little-endian byte
  order, for example by leveraging the <strong>pack()</strong> function with the <return>P</return> format code. The high-level
  interface provided by the <class>Random\Randomizer</class> will interpret the returned random bytes as unsigned
  little-endian integers if a numeric representation is required.
  
  It is strongly recommended that each bit of the returned string is uniformly and independently
  selected, as some applications require randomness based on the bit-level to work correctly. For
  example linear congruential generators often generate lower-quality randomness for the less
  significant bits of the return integer value and thus would not be appropriate for applications
  that require bit-level randomness.

<comment>Return:</comment>
  <info>string</info>  A non-empty string containing random bytes.
          
          The <class>Random\Randomizer</class> works with unsigned 64 bit integers internally. If the returned
          string contains more than 64 bit (8 byte) of randomness the exceeding bytes will be
          ignored. Other applications may be able to process more than 64 bit at once.


id: Random\Engine\Mt19937::__construct
type: function
doc:
<comment>Description:</comment>
  Constructs a new Mt19937 engine
  
  Because the Mt19937 (“Mersenne Twister”) engine accepts only a single 32 bit integer as the seed,
  the number of possible random sequences is limited to just 232 (i.e. 4,294,967,296), despite
  Mt19937’s huge period of 219937-1.
  
  When relying on either implicit or explicit random seeding, duplications will appear much earlier.
  Duplicated seeds are expected with 50% probability after less than 80,000 randomly generated seeds
  according to the birthday problem. A 10% probability of a duplicated seed happens after randomly
  generating roughly 30,000 seeds.
  
  This makes Mt19937 unsuitable for applications where duplicated sequences must not happen with
  more than a negligible probability. If reproducible seeding is required, both the
  <class>Random\Engine\Xoshiro256StarStar</class> and <class>Random\Engine\PcgOneseq128XslRr64</class> engines support much larger
  seeds that are unlikely to collide randomly. If reproducibility is not required, the
  <class>Random\Engine\Secure</class> engine provides cryptographically secure randomness.
  
  This function is
  currently not documented; only its argument list is available.

<comment>Param:</comment>
  <info>int|null</info>  <strong>$seed</strong>  Fills the state with values generated with a linear congruential generator that
                   was seeded with <strong>$seed</strong> interpreted as an unsigned 32 bit integer.
                   
                   If <strong>$seed</strong> is omitted or <info>null</info>, a random unsigned 32 bit integer will be used.
  <info>int</info>       <strong>$mode</strong>  Use one of the following constants to specify the implementation of the algorithm
                   to use. <info>MT_RAND_MT19937</info>: The correct Mt19937 implementation. <info>MT_RAND_PHP</info>: An
                   incorrect implementation for backwards compatibility with <strong>mt_srand()</strong> prior to PHP
                   7.1.0.
                   
                   This feature has been
                   DEPRECATED as of PHP 8.3.0. Relying on this feature
                   is highly discouraged.


id: Random\Engine\Mt19937::__debugInfo
type: function
doc:
<comment>Description:</comment>
  Returns the internal state of the engine
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>array</info>  


id: Random\Engine\Mt19937::__serialize
type: function
doc:
<comment>Description:</comment>
  Serializes the Mt19937 object
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>array</info>  


id: Random\Engine\Mt19937::__unserialize
type: function
doc:
<comment>Description:</comment>
  Deserializes the data parameter into a Mt19937 object
  
  This function is
  currently not documented; only its argument list is available.

<comment>Param:</comment>
  <info>array</info>  <strong>$data</strong>  

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Random\Engine\Mt19937::generate
type: function
doc:
<comment>Description:</comment>
  Generate 32 bits of randomness
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>string</info>  A string representing an unsigned 32 bit integer in little-endian order.


id: Random\Engine\PcgOneseq128XslRr64
type: class
doc:
<comment>Description:</comment>
  Implements a Permuted congruential generator (PCG) with 128 bits of state, XSL and RR output
  transformations, and 64 bits of output.


id: Random\Engine\PcgOneseq128XslRr64::__construct
type: function
doc:
<comment>Description:</comment>
  Constructs a new PCG Oneseq 128 XSL RR 64 engine
  
  This function is
  currently not documented; only its argument list is available.

<comment>Param:</comment>
  <info>string|int|null</info>  <strong>$seed</strong>  How the internal 128 bit (16 byte) state consisting of one unsigned 128
                          bit integer is seeded depends on the type used as the <strong>$seed</strong>.
                          TypeDescription<info>null</info> Fills the state with 16 random bytes generated using
                          the CSPRNG. <info>int</info> Fills the state by setting the state to <return>0</return>, advancing the
                          engine one step, adding the value of <strong>$seed</strong> interpreted as an unsigned 64
                          bit integer, and advancing the engine another step. <info>string</info> Fills the state
                          by interpreting a 16 byte <info>string</info> as a little-endian unsigned 128 bit
                          integer.


id: Random\Engine\PcgOneseq128XslRr64::__serialize
type: function
doc:
<comment>Description:</comment>
  Serializes the PcgOneseq128XslRr64 object
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>array</info>  


id: Random\Engine\PcgOneseq128XslRr64::__unserialize
type: function
doc:
<comment>Description:</comment>
  Deserializes the data parameter into a PcgOneseq128XslRr64 object
  
  This function is
  currently not documented; only its argument list is available.

<comment>Param:</comment>
  <info>array</info>  <strong>$data</strong>  

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Random\Engine\PcgOneseq128XslRr64::generate
type: function
doc:
<comment>Description:</comment>
  Generate 64 bits of randomness
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>string</info>  A string representing an unsigned 64 bit integer in little-endian order.


id: Random\Engine\PcgOneseq128XslRr64::jump
type: function
doc:
<comment>Description:</comment>
  Efficiently move the engine ahead multiple steps
  
  Moves the algorithm’s state ahead by the number of steps given by <strong>$advance</strong>, as if
  <strong>Random\Engine\PcgOneseq128XslRr64::generate()</strong> was called that many times.

<comment>Param:</comment>
  <info>int</info>  <strong>$advance</strong>  The number of steps to move ahead; must be <return>0</return> or greater.

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Random\Engine\Secure
type: class
doc:
<comment>Description:</comment>
  Generates cryptographically secure randomness using the operating system’s CSPRNG.
  
  The randomness generated by this <class>Random\Engine</class> is suitable for all applications, including the
  generation of long-term secrets, such as encryption keys.
  
  The <class>Random\Engine\Secure</class> engine is the recommended safe default choice, unless the application
  requires either reproducible sequences or very high performance.


id: Random\Engine\Secure::generate
type: function
doc:
<comment>Description:</comment>
  Generate cryptographically secure randomness
  
  Returns cryptographically secure randomness.
  
  The sources of randomness in the order of priority are as follows:
  
  Linux: getrandom(), /dev/urandom
  
  FreeBSD &gt;= 12 (PHP &gt;= 7.3): getrandom(), /dev/urandom
  
  Windows (PHP &gt;= 7.2): CNG-API
  
  Windows: CryptGenRandom
  
  macOS (PHP &gt;= 8.2; &gt;= 8.1.9; &gt;= 8.0.22 if CCRandomGenerateBytes is available at compile
  time): CCRandomGenerateBytes()
  
  macOS (PHP &gt;= 8.1; &gt;= 8.0.2): arc4random_buf(), /dev/urandom
  
  NetBSD &gt;= 7 (PHP &gt;= 7.1; &gt;= 7.0.1): arc4random_buf(), /dev/urandom
  
  OpenBSD &gt;= 5.5 (PHP &gt;= 7.1; &gt;= 7.0.1): arc4random_buf(), /dev/urandom
  
  DragonflyBSD (PHP &gt;= 8.1): getrandom(), /dev/urandom
  
  Solaris (PHP &gt;= 8.1): getrandom(), /dev/urandom
  
  Any combination of operating system and PHP version not previously mentioned: /dev/urandom
  
  If none of the sources are available or they all fail to generate randomness, then a
  <class>Random\RandomException</class> will be thrown.

<comment>Return:</comment>
  <info>string</info>  A string containing <info>PHP_INT_SIZE</info> cryptographically secure random bytes.


id: Random\Engine\Xoshiro256StarStar::__construct
type: function
doc:
<comment>Description:</comment>
  Constructs a new xoshiro256** engine
  
  This function is
  currently not documented; only its argument list is available.

<comment>Param:</comment>
  <info>string|int|null</info>  <strong>$seed</strong>  How the internal 256 bit (32 byte) state consisting of four unsigned 64
                          bit integers is seeded depends on the type used as the <strong>$seed</strong>.
                          TypeDescription<info>null</info> Fills the state with 32 random bytes generated using
                          the CSPRNG. <info>int</info> Fills the state with four consecutive values generated
                          with the SplitMix64 algorithm that was seeded with <strong>$seed</strong> interpreted as an
                          unsigned 64 bit integer. <info>string</info> Fills the state by interpreting a 32 byte
                          <info>string</info> as four little-endian unsigned 64 bit integers.


id: Random\Engine\Xoshiro256StarStar::__serialize
type: function
doc:
<comment>Description:</comment>
  Serializes the Xoshiro256StarStar object
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>array</info>  


id: Random\Engine\Xoshiro256StarStar::__unserialize
type: function
doc:
<comment>Description:</comment>
  Deserializes the data parameter into a Xoshiro256StarStar object
  
  This function is
  currently not documented; only its argument list is available.

<comment>Param:</comment>
  <info>array</info>  <strong>$data</strong>  

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Random\Engine\Xoshiro256StarStar::jump
type: function
doc:
<comment>Description:</comment>
  Efficiently move the engine ahead by 2^128 steps
  
  Moves the algorithm’s state ahead by 2128 steps, as if
  <strong>Random\Engine\Xoshiro256StarStar::generate()</strong> was called 2128 times.
  
  The purpose of a jump is to facilitate the creation of a new <class>Random\Engine\Xoshiro256StarStar</class>
  engine from an existing seeded <class>Random\Engine\Xoshiro256StarStar</class> engine. The seeded engine acts as
  a blueprint, which can be cloned and repeatedly jumped to create 2128 non-overlapping sequences
  with 2128 values each.

<comment>Return:</comment>
  <info>void</info>  No value is returned.

<comment>See Also:</comment>
   * <strong>Random\Engine\Xoshiro256StarStar::jumpLong()</strong>


id: Random\Engine\Xoshiro256StarStar::jumpLong
type: function
doc:
<comment>Description:</comment>
  Efficiently move the engine ahead by 2^192 steps
  
  Moves the algorithm’s state ahead by 2192 steps, as if
  <strong>Random\Engine\Xoshiro256StarStar::generate()</strong> was called 2192 times.
  
  The purpose of a long jump is to facilitate the creation of a new <class>Random\Engine\Xoshiro256StarStar</class>
  engine from an existing seeded <class>Random\Engine\Xoshiro256StarStar</class> engine. The seeded engine acts as
  a blueprint, which can be cloned and repeatedly jumped to create 264 non-overlapping sequences
  with 2192 values each.
  
  Long jumping may be combined with <strong>Random\Engine\Xoshiro256StarStar::jump()</strong>ing to further split
  each of the 264 sequences generated by long jumping, into 264 sequences of 2128 values each.

<comment>Return:</comment>
  <info>void</info>  No value is returned.

<comment>See Also:</comment>
   * <strong>Random\Engine\Xoshiro256StarStar::jump()</strong>


id: Random\RandomError
type: class
doc:
<comment>Description:</comment>
  Indicates that the used <class>Random\Engine</class> is broken, e.g. because it is severely biased.


id: Random\Randomizer
type: class
doc:
<comment>Description:</comment>
  Provides a high-level API to the randomness provided by an <class>Random\Engine</class>.


id: Random\Randomizer::__construct
type: function
doc:
<comment>Description:</comment>
  Constructs a new Randomizer
  
  This function is
  currently not documented; only its argument list is available.

<comment>Param:</comment>
  <info>Random\Engine|null</info>  <strong>$engine</strong>  The <class>Random\Engine</class> to use to generate randomness.
                               
                               If <strong>$engine</strong> is omitted or <info>null</info>, a new <class>Random\Engine\Secure</class> object will
                               be used.


id: Random\Randomizer::__serialize
type: function
doc:
<comment>Description:</comment>
  Serializes the Randomizer object
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>array</info>  


id: Random\Randomizer::__unserialize
type: function
doc:
<comment>Description:</comment>
  Deserializes the data parameter into a Randomizer object
  
  This function is
  currently not documented; only its argument list is available.

<comment>Param:</comment>
  <info>array</info>  <strong>$data</strong>  

<comment>Return:</comment>
  <info>void</info>  No value is returned.


id: Random\Randomizer::getBytes
type: function
doc:
<comment>Description:</comment>
  Get random bytes
  
  Generates a string containing uniformly selected random bytes with the requested <strong>$length</strong>.
  
  As the returned bytes are selected completely randomly, the resulting string is likely to contain
  unprintable characters or invalid UTF-8 sequences. It may be necessary to encode it before
  transmission or display.

<comment>Param:</comment>
  <info>int</info>  <strong>$length</strong>  The length of the random <info>string</info> that should be returned in bytes; must be <return>1</return> or
                greater.

<comment>Return:</comment>
  <info>string</info>  A <info>string</info> containing the requested number of random bytes.

<comment>See Also:</comment>
   * <strong>random_bytes()</strong>
   * <strong>bin2hex()</strong>
   * <strong>base64_encode()</strong>
   * Random\Randomizer::getBytesFromString


id: Random\Randomizer::getBytesFromString
type: function
doc:
<comment>Description:</comment>
  Get random bytes from a source string
  
  Generates a string containing uniformly selected random bytes from the input <strong>$string</strong> with the
  requested <strong>$length</strong>.
  
  The chance for a byte to be selected is proportional to its share of the input <strong>$string</strong>. If each
  byte occurs the same amount of times, each byte is equally likely to be selected.

<comment>Param:</comment>
  <info>string</info>  <strong>$string</strong>  The <info>string</info> from which the returned bytes are selected.
  <info>int</info>     <strong>$length</strong>  The length of the random <info>string</info> that should be returned in bytes; must be <return>1</return> or
                   greater.

<comment>Return:</comment>
  <info>string</info>  A <info>string</info> containing the requested number of random bytes taken from the input <strong>$string</strong>.

<comment>See Also:</comment>
   * Random\Randomizer::getBytes


id: Random\Randomizer::getFloat
type: function
doc:
<comment>Description:</comment>
  Get a uniformly selected float
  
  Returns a uniformly selected, equidistributed float from a requested interval.
  
  Due to the limited precision, not all real numbers can be exactly represented as a floating point
  number.
   If a number cannot be represented exactly, it is rounded to the nearest representable exact
  value.
   Furthermore, floats are not equally dense across the whole number line.
   Because floats use a binary exponent, the distance between two neighboring floats doubles at each
  power of two.
   In other words: There are the same number of representable floats between <return>1.0</return> and <return>2.0</return> as they are
  between <return>2.0</return> and <return>4.0</return>, <return>4.0</return> and <return>8.0</return>, <return>8.0</return> and <return>16.0</return>, and so on.
  
  Randomly sampling an arbitrary number within the requested interval, for example by dividing two
  integers, might result in a biased distribution for this reason.
   The necessary rounding will cause some floats to be returned more often than others, especially
  around powers of two when the density of floats changes.
  
  Random\Randomizer::getFloat implements an algorithm that will return a uniformly selected float
  from the largest possible set of exactly representable and equidistributed floats within the
  requested interval.
   The distance between the selectable floats (“step size”) matches the distance between the floats
  with the lowest density, i.e. the distance between floats at interval boundary with the larger
  absolute value.
   This means that not all representable floats within a given interval may be returned if the
  interval crosses one or more powers of two.
   Stepping will start from the interval boundary with the larger absolute value to ensure the steps
  align with the exactly representable floats.
  
  Closed interval boundaries will always be included in the set of selectable floats.
   Thus, if the size of the interval is not an exact multiple of the step size and the boundary with
  the smaller absolute value is a closed boundary, the distance between that boundary and its
  nearest selectable float will be smaller than the step size.
  
  Post-processing the returned floats is likely going to break the uniform equidistribution, because
  the intermediate floats within a mathematical operation are experiencing implicit rounding.
   The requested interval should match the desired interval as closely as possible and rounding
  should only be performed as an explicit operation right before displaying the selected number to a
  user.
  
  To give an example of how the algorithm works, consider a floating point representation that uses
  a 3-bit mantissa.
   This representation is capable of representing 8 different floating point values between
  consecutive powers of two.
   This means that between <return>1.0</return> and <return>2.0</return> all steps of size <return>0.125</return> are exactly representable and between
  <return>2.0</return> and <return>4.0</return> all steps of size <return>0.25</return> are exactly representable.
   In reality PHP’s floats use a 52-bit mantissa and can represent 252 different values between each
  power of two.
   This means that <return>1.0</return><return>1.125</return><return>1.25</return><return>1.375</return><return>1.5</return><return>1.625</return><return>1.75</return><return>1.875</return><return>2.0</return><return>2.25</return><return>2.5</return><return>2.75</return><return>3.0</return><return>3.25</return><return>3.5</return><return>3.75</return><return>4.0</return> are the exactly
  representable floats between <return>1.0</return> and <return>4.0</return>.
  
  Now consider that $randomizer-&gt;getFloat(1.625, 2.5, IntervalBoundary::ClosedOpen) is called,
  i.e. a random float starting at <return>1.625</return> until, but not including, <return>2.5</return> is requested.
   The algorithm first determines the step size at the boundary with the larger absolute value
  (<return>2.5</return>). The step size at that boundary is <return>0.25</return>.
  
  Note that the size of the requested interval is <return>0.875</return>, which is not an exact multiple of <return>0.25</return>.
   If the algorithm would start stepping at the lower bound <return>1.625</return>, it would encounter <return>2.125</return>, which
  is not exactly representable and would experience implicit rounding.
   Thus the algorithm starts stepping at the upper boundary <return>2.5</return>.
   The selectable values are: <return>2.25</return><return>2.0</return><return>1.75</return><return>1.625</return>
   <return>2.5</return> is not included, because the upper boundary of the requested interval is an open boundary.
   <return>1.625</return> is included, even though its distance to the nearest value <return>1.75</return> is <return>0.125</return>, which is smaller
  than the previously determined step size of <return>0.25</return>.
   The reason for that is that the requested interval is closed at the lower boundary (<return>1.625</return>) and
  closed boundaries are always included.
  
  Finally the algorithm uniformly selects one of the four selectable values at random and returns
  it.
  
  In the previous example, there are eight representable floating point numbers between each
  sub-interval delimited by a power of two.
   To give an example why dividing two integers would not work well to generate a random float,
  consider that there are 16 equidistributed floating point numbers in the right-open interval from
  <return>0.0</return> until, but not including, <return>1.0</return>. Half of them are the eight exactly representable values between
  <return>0.5</return> and <return>1.0</return>, the other half are the values between <return>0.0</return> and <return>1.0</return> that the step size of <return>0.0625</return>.
   These can easily be generated by dividing a random integer between <return>0</return> and <return>15</return> by <return>16</return> to obtain one
  of:
   <return>0.0</return><return>0.0625</return><return>0.125</return><return>0.1875</return><return>0.25</return><return>0.3125</return><return>0.375</return><return>0.4375</return><return>0.5</return><return>0.5625</return><return>0.625</return><return>0.6875</return><return>0.75</return><return>0.8125</return><return>0.875</return><return>0.9375</return>
  
  This random float could be scaled to right-open interval from <return>1.625</return> until, but not including, <return>2.75</return>
  by multiplying it with the size of the interval (<return>0.875</return>) and adding the minimum <return>1.625</return>. This
  so-called affine transformation would result in the values:
   <return>1.625</return> rounded to <return>1.625</return><return>1.679</return> rounded to <return>1.625</return><return>1.734</return> rounded to <return>1.75</return><return>1.789</return> rounded to <return>1.75</return><return>1.843</return>
  rounded to <return>1.875</return><return>1.898</return> rounded to <return>1.875</return><return>1.953</return> rounded to <return>2.0</return><return>2.007</return> rounded to <return>2.0</return><return>2.062</return> rounded to
  <return>2.0</return><return>2.117</return> rounded to <return>2.0</return><return>2.171</return> rounded to <return>2.25</return><return>2.226</return> rounded to <return>2.25</return><return>2.281</return> rounded to <return>2.25</return><return>2.335</return>
  rounded to <return>2.25</return><return>2.390</return> rounded to <return>2.5</return><return>2.445</return> rounded to <return>2.5</return>
   Note how the upper boundary of <return>2.5</return> would be returned, despite being an open boundary and thus
  being excluded.
   Also note how <return>2.0</return> and <return>2.25</return> are twice as likely to be returned compared to the other values.

<comment>Param:</comment>
  <info>float</info>                    <strong>$min</strong>       The lower bound of the interval.
  <info>float</info>                    <strong>$max</strong>       The upper bound of the interval.
  <info>Random\IntervalBoundary</info>  <strong>$boundary</strong>  Specifies whether the interval boundaries are possible return
                                      values.

<comment>Return:</comment>
  <info>float</info>  A uniformly selected, equidistributed float from the interval specified by <strong>$min</strong>, <strong>$max</strong>, and
         <strong>$boundary</strong>.
          Whether <strong>$min</strong> and <strong>$max</strong> are possible return values depends on the value of <strong>$boundary</strong>.

<comment>See Also:</comment>
   * Random\Randomizer::nextFloat
   * Random\Randomizer::getInt


id: Random\Randomizer::getInt
type: function
doc:
<comment>Description:</comment>
  Get a uniformly selected integer
  
  This function is
  currently not documented; only its argument list is available.

<comment>Param:</comment>
  <info>int</info>  <strong>$min</strong>  The lowest value to be returned.
  <info>int</info>  <strong>$max</strong>  The highest value to be returned.

<comment>Return:</comment>
  <info>int</info>  A uniformly selected integer from the closed interval [<strong>$min</strong>, <strong>$max</strong>]. Both <strong>$min</strong> and <strong>$max</strong> are
       possible return values.

<comment>See Also:</comment>
   * <strong>random_int()</strong>
   * Random\Randomizer::getFloat


id: Random\Randomizer::nextFloat
type: function
doc:
<comment>Description:</comment>
  Get a float from the right-open interval [0.0, 1.0)
  
  Returns a uniformly selected, equidistributed float from the right-open interval from <return>0.0</return> until,
  but not including, <return>1.0</return>.
  
  The chance for returned float to be within a given right-open sub-interval is proportial to the
  size of the sub-interval.
   This means that the chance for a float to be less than <return>0.5</return> is 50 %, which is equal to the chance
  for a float to be at least <return>0.5</return>.
   Likewise the chance for a float to be within the right-open interval from <return>0.2</return> until, but not
  including, <return>0.25</return> is exactly 5 %.
  
  This property makes it easy to leverage Random\Randomizer::nextFloat to generate a random boolean
  with a given chance by checking if the returned float is less than a given chance.
  
  The domain of the returnable floats of Random\Randomizer::nextFloat is identical to that of
  Randomizer::getFloat(0.0, 1.0, IntervalBoundary::ClosedOpen).
  
  The internal implementation of Random\Randomizer::nextFloat is more efficient.
  
  Scaling the return value to a different interval using multiplication or addition (a so-called
  affine transformation) might result in a bias in the resulting value as floats are not equally
  dense across the number line. As not all values can be exactly represented by a float, the result
  of the affine transformation might also result in values outside of the requested interval due to
  implicit rounding.
   An in-depth explanation of the problems with the affine transformation is given in the
  documentation for Random\Randomizer::getFloat.
  
  Use Random\Randomizer::getFloat to generate a random float within an arbitrary interval. Use
  Random\Randomizer::getInt to generate a random integer within an arbitrary interval.

<comment>Return:</comment>
  <info>float</info>  A uniformly selected, equidistributed float from the right-open
         (<return>IntervalBoundary::ClosedOpen</return>) interval [0.0, 1.0).
          <return>0.0</return> is a possible return value, <return>1.0</return> is not.

<comment>See Also:</comment>
   * Random\Randomizer::getFloat


id: Random\Randomizer::nextInt
type: function
doc:
<comment>Description:</comment>
  Get a positive integer
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>int</info>  A positive integer between 0 and a maximum value depending on the number of bytes returned
       from Random\Engine::generate. The exact maximum can be calculated as 2$engine_bytes * 8 - 1 -
       1.


id: Random\Randomizer::pickArrayKeys
type: function
doc:
<comment>Description:</comment>
  Select random array keys
  
  Uniformly selects <strong>$num</strong> distinct array keys of the input <strong>$array</strong>.
  
  Each key of the input <strong>$array</strong> is equally likely to be returned.
  
  The selection of the array keys depends on the internal structure of the input <strong>$array</strong>. The
  returned array keys might be different for two equal input arrays and two <class>Random\Engine</class>s with
  identical state, depending on how the input arrays have been created.

<comment>Param:</comment>
  <info>array</info>  <strong>$array</strong>  The array whose array keys are selected.
  <info>int</info>    <strong>$num</strong>    The number of array keys to return; must be between <return>1</return> and the number of elements in
                 <strong>$array</strong>.

<comment>Return:</comment>
  <info>array</info>  An <info>array</info> containing <strong>$num</strong> distinct array keys of <strong>$array</strong>.
         
         The returned <info>array</info> will be a list (<strong>array_is_list()</strong>). It will be a subset of the <info>array</info>
         returned by <strong>array_keys()</strong>.

<comment>See Also:</comment>
   * <strong>array_keys()</strong>


id: Random\Randomizer::shuffleArray
type: function
doc:
<comment>Description:</comment>
  Get a permutation of an array
  
  Returns a uniformly selected permutation of the input <strong>$array</strong>.
  
  Each possible permutation of the input <strong>$array</strong> is equally likely to be returned.

<comment>Param:</comment>
  <info>array</info>  <strong>$array</strong>  The <info>array</info> whose values are shuffled.
                 
                 The input <info>array</info> will not be modified.

<comment>Return:</comment>
  <info>array</info>  A permutation of the values of <strong>$array</strong>.
         
         Array keys of the input <strong>$array</strong> will not be preserved; the returned <info>array</info> will be a list
         (<strong>array_is_list()</strong>).


id: Random\Randomizer::shuffleBytes
type: function
doc:
<comment>Description:</comment>
  Get a byte-wise permutation of a string
  
  Returns a uniformly selected permutation of the input <strong>$bytes</strong>.
  
  Each possible permutation of the input <strong>$bytes</strong> is equally likely to be returned.

<comment>Param:</comment>
  <info>string</info>  <strong>$bytes</strong>  The <info>string</info> whose bytes are shuffled.
                  
                  The input <info>string</info> will not be modified.

<comment>Return:</comment>
  <info>string</info>  A permutation of the bytes of <strong>$bytes</strong>.


id: RarArchive
type: class
doc:
<comment>Description:</comment>
  This class represents a RAR archive, which may be formed by several volumes (parts) and which
  contains a number of RAR entries (i.e., files, directories and other special objects such as
  symbolic links).
  
  Objects of this class can be traversed, yielding the entries stored in the respective RAR archive.
  Those entries can also be obtained through RarArchive::getEntry and RarArchive::getEntries.


id: RarArchive::__toString
type: function
doc:
<comment>Description:</comment>
  Get text representation
  
  Provides a string representation for this <info>RarArchive</info> object. It currently shows the full path name
  of the archive volume that was opened and whether the resource is valid or was already closed
  through a call to RarArchive::close.
  
  This method may be used only for debugging purposes, as there are no guarantees as to which
  information the result contains or how it is formatted.

<comment>Return:</comment>
  <info>string</info>  A textual representation of this <info>RarArchive</info> object. The content of this representation is
          unspecified.


id: RarArchive::close
type: function
doc:
<comment>Description:</comment>
  Close RAR archive and free all resources
  
  Object-oriented style (method):
  
  Procedural style:
  
  Close RAR archive and free all allocated resources.

<comment>Param:</comment>
  <info>RarArchive</info>  <strong>$rarfile</strong>  A <info>RarArchive</info> object, opened with <strong>rar_open()</strong>.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.


id: RarArchive::getComment
type: function
doc:
<comment>Description:</comment>
  Get comment text from the RAR archive
  
  Object-oriented style (method):
  
  Procedural style:
  
  Get the (global) comment stored in the RAR archive. It may be up to 64 KiB long.
  
  This extension does not support comments at the entry level.

<comment>Param:</comment>
  <info>RarArchive</info>  <strong>$rarfile</strong>  A <info>RarArchive</info> object, opened with <strong>rar_open()</strong>.

<comment>Return:</comment>
  <info>string</info>  Returns the comment or <info>null</info> if there is none.
          
          RAR has currently no support for unicode comments. The encoding of the result of this
          function is not specified, but it will probably be Windows-1252.


id: RarArchive::getEntries
type: function
doc:
<comment>Description:</comment>
  Get full list of entries from the RAR archive
  
  Object-oriented style (method):
  
  Procedural style:
  
  Get entries list (files and directories) from the RAR archive.
  
  If the archive has entries with the same name, this method, together with <info>RarArchive</info> <return>foreach</return>
  iteration and array-like access with numeric indexes, are the only ones to access all the entries
  (i.e., RarArchive::getEntry and the <return>rar://</return> wrapper are insufficient).

<comment>Param:</comment>
  <info>RarArchive</info>  <strong>$rarfile</strong>  A <info>RarArchive</info> object, opened with <strong>rar_open()</strong>.

<comment>Return:</comment>
  <info>array|false</info>  <strong>rar_list()</strong> returns array of <info>RarEntry</info> objects or <info>false</info> on failure.

<comment>See Also:</comment>
   * RarArchive::getEntry
   * <return>rar://</return> wrapper


id: RarArchive::getEntry
type: function
doc:
<comment>Description:</comment>
  Get entry object from the RAR archive
  
  Object-oriented style (method):
  
  Procedural style:
  
  Get entry object (file or directory) from the RAR archive.
  
  You can also get entry objects using RarArchive::getEntries.
  
  Note that a RAR archive can have multiple entries with the same name; this method will retrieve
  only the first.

<comment>Param:</comment>
  <info>RarArchive</info>  <strong>$rarfile</strong>    A <info>RarArchive</info> object, opened with <strong>rar_open()</strong>.
  <info>string</info>      <strong>$entryname</strong>  Path to the entry within the RAR archive.
                          
                          The path must be the same returned by RarEntry::getName.

<comment>Return:</comment>
  <info>RarEntry|false</info>  Returns the matching <info>RarEntry</info> object  or <info>false</info> on failure.

<comment>See Also:</comment>
   * RarArchive::getEntries
   * <return>rar://</return> wrapper


id: RarArchive::isBroken
type: function
doc:
<comment>Description:</comment>
  Test whether an archive is broken (incomplete)
  
  Object-oriented style (method):
  
  Procedural style:
  
  This function determines whether an archive is incomplete, i.e., if a volume is missing or a
  volume is truncated.

<comment>Param:</comment>
  <info>RarArchive</info>  <strong>$rarfile</strong>  A <info>RarArchive</info> object, opened with <strong>rar_open()</strong>.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> if the archive is broken, <info>false</info> otherwise. This function may also return <info>false</info>
        if the passed file has already been closed. The only way to tell the two cases apart is to
        enable exceptions with RarException::setUsingExceptions; however, this should be unnecessary
        as a program should not operate on closed files.

<comment>See Also:</comment>
   * RarArchive::setAllowBroken


id: RarArchive::isSolid
type: function
doc:
<comment>Description:</comment>
  Check whether the RAR archive is solid
  
  Object-oriented style (method):
  
  Procedural style:
  
  Check whether the RAR archive is solid. Individual file extraction is slower on solid archives.

<comment>Param:</comment>
  <info>RarArchive</info>  <strong>$rarfile</strong>  A <info>RarArchive</info> object, opened with <strong>rar_open()</strong>.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> if the archive is solid, <info>false</info> otherwise.


id: RarArchive::open
type: function
doc:
<comment>Description:</comment>
  Open RAR archive
  
  Object-oriented style (method):
  
  Procedural style:
  
  Open specified RAR archive and return <info>RarArchive</info> instance representing it.
  
  If opening a multi-volume archive, the path of the first volume should be passed as the first
  parameter. Otherwise, not all files will be shown. This is by design.

<comment>Param:</comment>
  <info>string</info>    <strong>$filename</strong>         Path to the Rar archive.
  <info>string</info>    <strong>$password</strong>         A plain password, if needed to decrypt the headers. It will also be
                              used by default if encrypted files are found. Note that the files may
                              have different passwords in respect to the headers and among them.
  <info>callable</info>  <strong>$volume_callback</strong>  A function that receives one parameter – the path of the volume that
                              was not found – and returns a string with the correct path for such
                              volume or <info>null</info> if such volume does not exist or is not known. The
                              programmer should ensure the passed function doesn't cause loops as
                              this function is called repeatedly if the path returned in a previous
                              call did not correspond to the needed volume. Specifying this
                              parameter omits the notice that would otherwise be emitted whenever a
                              volume is not found; an implementation that only returns <info>null</info> can
                              therefore be used to merely omit such notices.

<comment>Return:</comment>
  <info>RarArchive|false</info>  Returns the requested <info>RarArchive</info> instance  or <info>false</info> on failure.

<comment>See Also:</comment>
   * <return>rar://</return> wrapper


id: RarArchive::setAllowBroken
type: function
doc:
<comment>Description:</comment>
  Whether opening broken archives is allowed
  
  Object-oriented style (method):
  
  Procedural style:
  
  This method defines whether broken archives can be read or all the operations that attempt to
  extract the archive entries will fail. Broken archives are archives for which no error is detected
  when the file is opened but an error occurs when reading the entries.

<comment>Param:</comment>
  <info>RarArchive</info>  <strong>$rarfile</strong>       A <info>RarArchive</info> object, opened with <strong>rar_open()</strong>.
  <info>bool</info>        <strong>$allow_broken</strong>  Whether to allow reading broken files (<info>true</info>) or not (<info>false</info>).

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info>  or <info>false</info> on failure. It will only fail if the file has already been closed.

<comment>See Also:</comment>
   * RarArchive::isBroken


id: RarEntry
type: class
doc:
<comment>Description:</comment>
  A RAR entry, representing a directory or a compressed file inside a RAR archive.


id: RarEntry::ATTRIBUTE_UNIX_BLOCK_DEV
type: constant
doc:
<comment>Description:</comment>
  Unix block devices will have attributes whose last four bits have this value. To be used with
  RarEntry::getAttr on entries whose host OS is UNIX and with the constant
  <info>RarEntry::ATTRIBUTE_UNIX_FINAL_QUARTET</info>.


id: RarEntry::ATTRIBUTE_UNIX_CHAR_DEV
type: constant
doc:
<comment>Description:</comment>
  Unix character devices will have attributes whose last four bits have this value. To be used with
  RarEntry::getAttr on entries whose host OS is UNIX and with the constant
  <info>RarEntry::ATTRIBUTE_UNIX_FINAL_QUARTET</info>.


id: RarEntry::ATTRIBUTE_UNIX_DIRECTORY
type: constant
doc:
<comment>Description:</comment>
  Unix directories will have attributes whose last four bits have this value. To be used with
  RarEntry::getAttr on entries whose host OS is UNIX and with the constant
  <info>RarEntry::ATTRIBUTE_UNIX_FINAL_QUARTET</info>. See also RarEntry::isDirectory, which also works with
  entries that were added in other operating systems.


id: RarEntry::ATTRIBUTE_UNIX_FIFO
type: constant
doc:
<comment>Description:</comment>
  Unix FIFOs will have attributes whose last four bits have this value. To be used with
  RarEntry::getAttr on entries whose host OS is UNIX and with the constant
  <info>RarEntry::ATTRIBUTE_UNIX_FINAL_QUARTET</info>.


id: RarEntry::ATTRIBUTE_UNIX_FINAL_QUARTET
type: constant
doc:
<comment>Description:</comment>
  Mask to isolate the last four bits (nibble) of UNIX attributes (_S_IFMT, the type of file mask).
  To be used with RarEntry::getAttr on entries whose host OS is UNIX and with the constants
  <info>RarEntry::ATTRIBUTE_UNIX_FIFO</info>, <info>RarEntry::ATTRIBUTE_UNIX_CHAR_DEV</info>,
  <info>RarEntry::ATTRIBUTE_UNIX_DIRECTORY</info>, <info>RarEntry::ATTRIBUTE_UNIX_BLOCK_DEV</info>,
  <info>RarEntry::ATTRIBUTE_UNIX_REGULAR_FILE</info>, <info>RarEntry::ATTRIBUTE_UNIX_SYM_LINK</info> and
  <info>RarEntry::ATTRIBUTE_UNIX_SOCKET</info>.


id: RarEntry::ATTRIBUTE_UNIX_GROUP_EXECUTE
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a UNIX entry that is group executable. To be used with RarEntry::getAttr on
  entries whose host OS is UNIX.


id: RarEntry::ATTRIBUTE_UNIX_GROUP_READ
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a UNIX entry that is group readable. To be used with RarEntry::getAttr on
  entries whose host OS is UNIX.


id: RarEntry::ATTRIBUTE_UNIX_GROUP_WRITE
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a UNIX entry that is group writable. To be used with RarEntry::getAttr on
  entries whose host OS is UNIX.


id: RarEntry::ATTRIBUTE_UNIX_OWNER_EXECUTE
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a UNIX entry that is owner executable. To be used with RarEntry::getAttr on
  entries whose host OS is UNIX.


id: RarEntry::ATTRIBUTE_UNIX_OWNER_READ
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a UNIX entry that is owner readable. To be used with RarEntry::getAttr on
  entries whose host OS is UNIX.


id: RarEntry::ATTRIBUTE_UNIX_OWNER_WRITE
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a UNIX entry that is owner writable. To be used with RarEntry::getAttr on
  entries whose host OS is UNIX.


id: RarEntry::ATTRIBUTE_UNIX_REGULAR_FILE
type: constant
doc:
<comment>Description:</comment>
  Unix regular files (not directories) will have attributes whose last four bits have this value. To
  be used with RarEntry::getAttr on entries whose host OS is UNIX and with the constant
  <info>RarEntry::ATTRIBUTE_UNIX_FINAL_QUARTET</info>. See also RarEntry::isDirectory, which also works with
  entries that were added in other operating systems.


id: RarEntry::ATTRIBUTE_UNIX_SETGID
type: constant
doc:
<comment>Description:</comment>
  Bit that represents the UNIX setgid attribute. To be used with RarEntry::getAttr on entries whose
  host OS is UNIX.


id: RarEntry::ATTRIBUTE_UNIX_SETUID
type: constant
doc:
<comment>Description:</comment>
  Bit that represents the UNIX setuid attribute. To be used with RarEntry::getAttr on entries whose
  host OS is UNIX.


id: RarEntry::ATTRIBUTE_UNIX_SOCKET
type: constant
doc:
<comment>Description:</comment>
  Unix sockets will have attributes whose last four bits have this value. To be used with
  RarEntry::getAttr on entries whose host OS is UNIX and with the constant
  <info>RarEntry::ATTRIBUTE_UNIX_FINAL_QUARTET</info>.


id: RarEntry::ATTRIBUTE_UNIX_STICKY
type: constant
doc:
<comment>Description:</comment>
  Bit that represents the UNIX sticky bit. To be used with RarEntry::getAttr on entries whose host
  OS is UNIX.


id: RarEntry::ATTRIBUTE_UNIX_SYM_LINK
type: constant
doc:
<comment>Description:</comment>
  Unix symbolic links will have attributes whose last four bits have this value. To be used with
  RarEntry::getAttr on entries whose host OS is UNIX and with the constant
  <info>RarEntry::ATTRIBUTE_UNIX_FINAL_QUARTET</info>.


id: RarEntry::ATTRIBUTE_UNIX_WORLD_EXECUTE
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a UNIX entry that is world executable. To be used with RarEntry::getAttr on
  entries whose host OS is UNIX.


id: RarEntry::ATTRIBUTE_UNIX_WORLD_READ
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a UNIX entry that is world readable. To be used with RarEntry::getAttr on
  entries whose host OS is UNIX.


id: RarEntry::ATTRIBUTE_UNIX_WORLD_WRITE
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a UNIX entry that is world writable. To be used with RarEntry::getAttr on
  entries whose host OS is UNIX.


id: RarEntry::ATTRIBUTE_WIN_ARCHIVE
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a Windows entry with an archive attribute. To be used with RarEntry::getAttr
  on entries whose host OS is Microsoft Windows.


id: RarEntry::ATTRIBUTE_WIN_COMPRESSED
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a Windows entry with a compressed attribute (NTFS only). To be used with
  RarEntry::getAttr on entries whose host OS is Microsoft Windows.


id: RarEntry::ATTRIBUTE_WIN_DEVICE
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a Windows entry with a device attribute. To be used with RarEntry::getAttr on
  entries whose host OS is Microsoft Windows.


id: RarEntry::ATTRIBUTE_WIN_DIRECTORY
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a Windows entry with a directory attribute (entry is a directory). To be used
  with RarEntry::getAttr on entries whose host OS is Microsoft Windows. See also
  RarEntry::isDirectory, which also works with entries that were not added in WinRAR.


id: RarEntry::ATTRIBUTE_WIN_ENCRYPTED
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a Windows entry with an encrypted attribute (NTFS only). To be used with
  RarEntry::getAttr on entries whose host OS is Microsoft Windows.


id: RarEntry::ATTRIBUTE_WIN_HIDDEN
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a Windows entry with a hidden attribute. To be used with RarEntry::getAttr on
  entries whose host OS is Microsoft Windows.


id: RarEntry::ATTRIBUTE_WIN_NORMAL
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a Windows entry with a normal file attribute (entry is NOT a directory). To be
  used with RarEntry::getAttr on entries whose host OS is Microsoft Windows. See also
  RarEntry::isDirectory, which also works with entries that were not added in WinRAR.


id: RarEntry::ATTRIBUTE_WIN_NOT_CONTENT_INDEXED
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a Windows entry with a not content indexed attribute (entry is to be indexed).
  To be used with RarEntry::getAttr on entries whose host OS is Microsoft Windows.


id: RarEntry::ATTRIBUTE_WIN_OFFLINE
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a Windows entry with an offline attribute (entry is offline and not
  accessible). To be used with RarEntry::getAttr on entries whose host OS is Microsoft Windows.


id: RarEntry::ATTRIBUTE_WIN_READONLY
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a Windows entry with a read-only attribute. To be used with RarEntry::getAttr
  on entries whose host OS is Microsoft Windows.


id: RarEntry::ATTRIBUTE_WIN_REPARSE_POINT
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a Windows entry with a reparse point attribute (entry is an NTFS reparse
  point, e.g. a directory junction or a mount file system). To be used with RarEntry::getAttr on
  entries whose host OS is Microsoft Windows.


id: RarEntry::ATTRIBUTE_WIN_SPARSE_FILE
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a Windows entry with a sparse file attribute (file is an NTFS sparse file). To
  be used with RarEntry::getAttr on entries whose host OS is Microsoft Windows.


id: RarEntry::ATTRIBUTE_WIN_SYSTEM
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a Windows entry with a system attribute. To be used with RarEntry::getAttr on
  entries whose host OS is Microsoft Windows.


id: RarEntry::ATTRIBUTE_WIN_TEMPORARY
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a Windows entry with a temporary attribute. To be used with RarEntry::getAttr
  on entries whose host OS is Microsoft Windows.


id: RarEntry::ATTRIBUTE_WIN_VIRTUAL
type: constant
doc:
<comment>Description:</comment>
  Bit that represents a Windows entry with a virtual attribute. To be used with RarEntry::getAttr on
  entries whose host OS is Microsoft Windows.


id: RarEntry::HOST_BEOS
type: constant
doc:
<comment>Description:</comment>
  If the return value of RarEntry::getHostOs equals this constant, BeOS was used to add this entry.
  Intended to replace <info>RAR_HOST_BEOS</info>.


id: RarEntry::HOST_MACOS
type: constant
doc:
<comment>Description:</comment>
  If the return value of RarEntry::getHostOs equals this constant, Mac OS was used to add this
  entry.


id: RarEntry::HOST_MSDOS
type: constant
doc:
<comment>Description:</comment>
  If the return value of RarEntry::getHostOs equals this constant, MS-DOS was used to add this
  entry. Use instead of <info>RAR_HOST_MSDOS</info>.


id: RarEntry::HOST_OS2
type: constant
doc:
<comment>Description:</comment>
  If the return value of RarEntry::getHostOs equals this constant, OS/2 was used to add this entry.
  Intended to replace <info>RAR_HOST_OS2</info>.


id: RarEntry::HOST_UNIX
type: constant
doc:
<comment>Description:</comment>
  If the return value of RarEntry::getHostOs equals this constant, an unspecified UNIX OS was used
  to add this entry. Intended to replace <info>RAR_HOST_UNIX</info>.


id: RarEntry::HOST_WIN32
type: constant
doc:
<comment>Description:</comment>
  If the return value of RarEntry::getHostOs equals this constant, Microsoft Windows was used to add
  this entry. Intended to replace <info>RAR_HOST_WIN32</info>.


id: RarEntry::__toString
type: function
doc:
<comment>Description:</comment>
  Get text representation of entry
  
  RarEntry::__toString returns a textual representation for this entry. It includes whether the
  entry is a file or a directory (symbolic links and other special objects will be treated as
  files), the UTF-8 name of the entry and its CRC. The form and content of this representation may
  be changed in the future, so they cannot be relied upon.

<comment>Return:</comment>
  <info>string</info>  A textual representation for the entry.


id: RarEntry::extract
type: function
doc:
<comment>Description:</comment>
  Extract entry from the archive
  
  RarEntry::extract extracts the entry's data. It will create new file in the specified <strong>$dir</strong> with
  the name identical to the entry's name, unless the second argument is specified. See below for
  more information.

<comment>Param:</comment>
  <info>string</info>  <strong>$dir</strong>            Path to the directory where files should be extracted. This parameter is
                          considered if and only if <strong>$filepath</strong> is not. If both parameters are empty
                          an extraction to the current directory will be attempted.
  <info>string</info>  <strong>$filepath</strong>       Path (relative or absolute) containing the directory and filename of the
                          extracted file. This parameter overrides both the parameter <strong>$dir</strong> and the
                          original file name.
  <info>string</info>  <strong>$password</strong>       The password used to encrypt this entry. If the entry is not encrypted,
                          this value will not be used and can be omitted. If this parameter is
                          omitted and the entry is encrypted, the password given to <strong>rar_open()</strong>, if
                          any, will be used. If a wrong password is given, either explicitly or
                          implicitly via <strong>rar_open()</strong>, CRC checking will fail and this method will
                          fail and return <info>false</info>. If no password is given and one is required, this
                          method will fail and return <info>false</info>. You can check whether an entry is
                          encrypted with RarEntry::isEncrypted.
  <info>bool</info>    <strong>$extended_data</strong>  If <info>true</info>, extended information such as NTFS ACLs and Unix owner information
                          will be set in the extract files, as long as it's present in the archive.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> on success or <info>false</info> on failure.

<comment>See Also:</comment>
   * RarEntry::getStream
   * <return>rar://</return> wrapper


id: RarEntry::getAttr
type: function
doc:
<comment>Description:</comment>
  Get attributes of the entry
  
  Returns the OS-dependent attributes of the archive entry.

<comment>Return:</comment>
  <info>int</info>  Returns the attributes or <info>false</info> on error.

<comment>See Also:</comment>
   * RarEntry::getHostOs
   * The constants in <class>RarEntry</class>


id: RarEntry::getCrc
type: function
doc:
<comment>Description:</comment>
  Get CRC of the entry
  
  Returns an hexadecimal string representation of the CRC of the archive entry.

<comment>Return:</comment>
  <info>string</info>  Returns the CRC of the archive entry or <info>false</info> on error.


id: RarEntry::getFileTime
type: function
doc:
<comment>Description:</comment>
  Get entry last modification time
  
  Gets entry last modification time.

<comment>Return:</comment>
  <info>string</info>  Returns entry last modification time as string in format  <return>YYYY-MM-DD HH:II:SS</return>, or <info>false</info> on
          error.


id: RarEntry::getHostOs
type: function
doc:
<comment>Description:</comment>
  Get entry host OS
  
  Returns the code of the host OS of the archive entry.

<comment>Return:</comment>
  <info>int</info>  Returns the code of the host OS, or <info>false</info> on error.

<comment>See Also:</comment>
   * RarEntry::extract


id: RarEntry::getMethod
type: function
doc:
<comment>Description:</comment>
  Get pack method of the entry
  
  RarEntry::getMethod returns number of the method used when adding current archive entry.

<comment>Return:</comment>
  <info>int</info>  Returns the method number or <info>false</info> on error.


id: RarEntry::getName
type: function
doc:
<comment>Description:</comment>
  Get name of the entry
  
  Returns the name (with path) of the archive entry.

<comment>Return:</comment>
  <info>string</info>  Returns the entry name as a string, or <info>false</info> on error.


id: RarEntry::getPackedSize
type: function
doc:
<comment>Description:</comment>
  Get packed size of the entry
  
  Get packed size of the archive entry.
  
  Note that on platforms with 32-bit longs (that includes Windows x64), the maximum size returned is
  capped at 2 GiB. Check the constant <info>PHP_INT_MAX</info>.

<comment>Return:</comment>
  <info>int</info>  Returns the packed size, or <info>false</info> on error.


id: RarEntry::getStream
type: function
doc:
<comment>Description:</comment>
  Get file handler for entry
  
  Returns a file handler that supports read operations. This handler provides on-the-fly
  decompression for this entry.
  
  The handler is not invalidated by calling <strong>rar_close()</strong>.
  
  The resulting stream has no integrity verification. In particular, file corruption and decryption
  with a wrong a key will not be detected. It is the programmer's responsability to use the entry's
  CRC to check for integrity, if he so wishes.

<comment>Param:</comment>
  <info>string</info>  <strong>$password</strong>  The password used to encrypt this entry. If the entry is not encrypted, this
                     value will not be used and can be omitted. If this parameter is omitted and the
                     entry is encrypted, the password given to <strong>rar_open()</strong>, if any, will be used. If
                     a wrong password is given, either explicitly or implicitly via <strong>rar_open()</strong>, this
                     method's resulting stream will produce wrong output. If no password is given
                     and one is required, this method will fail and return <info>false</info>. You can check
                     whether an entry is encrypted with RarEntry::isEncrypted.

<comment>Return:</comment>
  <info>resource|false</info>  The file handler  or <info>false</info> on failure.

<comment>See Also:</comment>
   * RarEntry::extract
   * <return>rar://</return> wrapper


id: RarEntry::getUnpackedSize
type: function
doc:
<comment>Description:</comment>
  Get unpacked size of the entry
  
  Get unpacked size of the archive entry.
  
  Note that on platforms with 32-bit longs (that includes Windows x64), the maximum size returned is
  capped at 2 GiB. Check the constant <info>PHP_INT_MAX</info>.

<comment>Return:</comment>
  <info>int</info>  Returns the unpacked size, or <info>false</info> on error.


id: RarEntry::getVersion
type: function
doc:
<comment>Description:</comment>
  Get minimum version of RAR program required to unpack the entry
  
  Returns minimum version of RAR program (e.g. WinRAR) required to unpack the entry. It is encoded
  as 10 * major version + minor version.

<comment>Return:</comment>
  <info>int</info>  Returns the version or <info>false</info> on error.


id: RarEntry::isDirectory
type: function
doc:
<comment>Description:</comment>
  Test whether an entry represents a directory
  
  Tests whether the current entry is a directory.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> if this entry is a directory and <info>false</info> otherwise.


id: RarEntry::isEncrypted
type: function
doc:
<comment>Description:</comment>
  Test whether an entry is encrypted
  
  Tests whether the current entry contents are encrypted.
  
  The password used may differ between files inside the same RAR archive.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> if the current entry is encrypted and <info>false</info> otherwise.


id: RarException
type: class
doc:
<comment>Description:</comment>
  This class serves two purposes: it is the type of the exceptions thrown by the RAR extension
  functions and methods and it allows, through static methods to query and define the error
  behaviour of the extension, i.e., whether exceptions are thrown or only warnings are emitted.
  
  The following error codes are used:
  
  -1 - error outside UnRAR library
  
  11 - insufficient memory
  
  12 - bad data
  
  13 - bad archive
  
  14 - unknown format
  
  15 - file open error
  
  16 - file create error
  
  17 - file close error
  
  18 - read error
  
  19 - write error
  
  20 - buffer too small
  
  21 - unknown RAR error
  
  22 - password required but not given


id: RarException::isUsingExceptions
type: function
doc:
<comment>Description:</comment>
  Check whether error handling with exceptions is in use
  
  Checks whether the RAR functions will emit warnings and return error values or whether they will
  throw exceptions in most of the circumstances (does not include some programmatic errors such as
  passing the wrong type of arguments).

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> if exceptions are being used, <info>false</info> otherwise.

<comment>See Also:</comment>
   * RarException::setUsingExceptions


id: RarException::setUsingExceptions
type: function
doc:
<comment>Description:</comment>
  Activate and deactivate error handling with exceptions
  
  If and only if the argument is <info>true</info>, then, instead of emitting warnings and returning a special
  value indicating error when the UnRAR library encounters an error, an exception of type
  <info>RarException</info> will be thrown.
  
  Exceptions will also be thrown for the following errors, which occur outside the library (their
  error code will be -1):
  
  attempting some operations on a closed <info>RarArchive</info> object or a <info>RarEntry</info> object relative to the
  first;
  
  attempting to get an entry that does not exist with RarArchive::getEntry.

<comment>Param:</comment>
  <info>bool</info>  <strong>$using_exceptions</strong>  Should be <info>true</info> to activate exception throwing, <info>false</info> to deactivate (the
                           default).

<comment>Return:</comment>
  <info>void</info>  No value is returned.

<comment>See Also:</comment>
   * RarException::isUsingExceptions


id: RecursiveArrayIterator
type: class
doc:
<comment>Description:</comment>
  This iterator allows for unsetting and modifying values and keys while iterating over arrays and
  objects, in the same way as the <info>ArrayIterator</info>. Additionally, it is possible to iterate over the
  current iterator entry.


id: RecursiveArrayIterator::CHILD_ARRAYS_ONLY
type: constant
doc:
<comment>Description:</comment>
  Treat only arrays (not objects) as having children for recursive iteration.


id: RecursiveArrayIterator::getChildren
type: function
doc:
<comment>Description:</comment>
  Returns an iterator for the current entry if it is an array or an object
  
  Returns an iterator for the current iterator entry.

<comment>Return:</comment>
  <info>RecursiveArrayIterator|null</info>  An iterator for the current entry, if it is an <info>array</info> or <info>object</info>; or
                               <info>null</info> on failure.

<comment>See Also:</comment>
   * <strong>RecursiveArrayIterator::hasChildren()</strong>


id: RecursiveArrayIterator::hasChildren
type: function
doc:
<comment>Description:</comment>
  Returns whether current entry is an array or an object
  
  Returns whether current entry is an <info>array</info> or an <info>object</info> for which an iterator can be obtained via
  RecursiveArrayIterator::getChildren.

<comment>Return:</comment>
  <info>bool</info>  Returns <info>true</info> if the current entry is an <info>array</info> or an <info>object</info>, otherwise <info>false</info> is returned.

<comment>See Also:</comment>
   * <strong>RecursiveArrayIterator::getChildren()</strong>


id: RecursiveCachingIterator::__construct
type: function
doc:
<comment>Description:</comment>
  Construct
  
  Constructs a new <class>RecursiveCachingIterator</class>, which consists of a passed in <strong>$iterator</strong>.
  
  This function is
  currently not documented; only its argument list is available.

<comment>Param:</comment>
  <info>Iterator</info>  <strong>$iterator</strong>  The iterator being used.
  <info>int</info>       <strong>$flags</strong>     The flags. Use <info>CALL_TOSTRING</info> to call  RecursiveCachingIterator::__toString
                       for every element (the default), and/or <info>CATCH_GET_CHILD</info> to catch exceptions
                       when trying to get children.

<comment>See Also:</comment>
   * CachingIterator::__construct


id: RecursiveCachingIterator::getChildren
type: function
doc:
<comment>Description:</comment>
  Return the inner iterator's children as a RecursiveCachingIterator
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>RecursiveCachingIterator|null</info>  The inner iterator's children, as a RecursiveCachingIterator; or
                                 <info>null</info> if there is no children.


id: RecursiveCachingIterator::hasChildren
type: function
doc:
<comment>Description:</comment>
  Check whether the current element of the inner iterator has children
  
  This function is
  currently not documented; only its argument list is available.

<comment>Return:</comment>
  <info>bool</info>  <info>true</info> if the inner iterator has children, otherwise <info>false</info>


id: RecursiveCallbackFilterIterator::__construct
type: function
doc:
<comment>Description:</comment>
  Create a RecursiveCallbackFilterIterator from a RecursiveIterator
  
  Creates a filtered iterator from a RecursiveIterator using the <strong>$callback</strong> to determine which  items
  are accepted or rejected.

<comment>Param:</comment>
  <info>RecursiveIterator</info>  <strong>$iterator</strong>  The recursive iterator to be filtered.
  <info>callable</info>           <strong>$callback</strong>  The callback, which should return <info>true</info> to accept the current item or
                                <info>false</info> otherwise. See Examples.
                                
                                May be any valid <info>callable</info> value.

<comment>See Also:</comment>
   * RecursiveCallbackFilterIterator Examples
   * RecursiveCallbackFilterIterator::getChildren
   * RecursiveCallbackFilteriterator::hasChildren


