DefineFunction(array('name' => "__get", 'flags' => HasDocComment, 'return' => array('type' => Variant), 'args' => array(array('name' => "name", 'type' => Variant))));
DefineFunction(array('name' => "__set", 'flags' => HasDocComment, 'return' => array('type' => Variant), 'args' => array(array('name' => "name", 'type' => Variant), array('name' => "value", 'type' => Variant))));
DefineFunction(array('name' => "__isset", 'flags' => HasDocComment, 'return' => array('type' => Boolean), 'args' => array(array('name' => "name", 'type' => Variant))));
DefineFunction(array('name' => "__unset", 'flags' => HasDocComment, 'return' => array('type' => Variant), 'args' => array(array('name' => "name", 'type' => Variant))));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "LibXMLError", 'desc' => "Contains various information about errors thrown by libxml. The error codes are described within the official » xmlError API documentation.", 'flags' => HasDocComment));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "SimpleXMLElementIterator", 'desc' => "", 'flags' => HasDocComment, 'footer' => <<<EOT
public:
void reset_iterator(c_simplexmlelement *parent);
c_simplexmlelement *m_parent;
ArrayIter *m_iter1;
ArrayIter *m_iter2;
Object m_temp;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "current", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "key", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "next", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "rewind", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "valid", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
DefineFunction(array('name' => "fetchobject", 'desc' => "Fetches the next row and returns it as an object. This function is an alternative to PDOStatement::fetch() with PDO::FETCH_CLASS or PDO::FETCH_OBJ style.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns an instance of the required class with property names that correspond to the column names or FALSE on failure."), 'args' => array(array('name' => "class_name", 'type' => String, 'value' => "null_string", 'desc' => "Name of the created class."), array('name' => "ctor_args", 'type' => Variant, 'value' => "null", 'desc' => "Elements of this array are passed to the constructor."))));
DefineFunction(array('name' => "fetchcolumn", 'desc' => "Returns a single column from the next row of a result set or FALSE if there are no more rows.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "PDOStatement::fetchColumn() returns a single column in the next row of a result set. Warning\n\nThere is no way to return another column from the same row if you use PDOStatement::fetchColumn() to retrieve data."), 'args' => array(array('name' => "column_numner", 'type' => Int64, 'value' => "0", 'desc' => "0-indexed number of the column you wish to retrieve from the row. If no value is supplied, PDOStatement::fetchColumn() fetches the first column."))));
DefineFunction(array('name' => "fetchall", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "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.\n\nUsing 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 SORT BY clauses in SQL to restrict results before retrieving and processing them with PHP."), 'args' => array(array('name' => "how", 'type' => Int64, 'value' => "q_PDO_FETCH_BOTH", 'desc' => "Controls the contents of the returned array as documented in PDOStatement::fetch().\n\nTo return an array consisting of all values of a single column from the result set, specify PDO::FETCH_COLUMN. You can specify which column you want with the column-index parameter.\n\nTo fetch only the unique values of a single column from the result set, bitwise-OR PDO::FETCH_COLUMN with PDO::FETCH_UNIQUE.\n\nTo return an associative array grouped by the values of a specified column, bitwise-OR PDO::FETCH_COLUMN with PDO::FETCH_GROUP."), array('name' => "class_name", 'type' => Variant, 'value' => "null", 'desc' => "Returns the indicated 0-indexed column when the value of fetch_style is PDO::FETCH_COLUMN."), array('name' => "ctor_args", 'type' => Variant, 'value' => "null", 'desc' => "Arguments of custom class constructor."))));
DefineFunction(array('name' => "bindvalue", 'desc' => "Binds a value to a corresponding named or question mark placeholder in the SQL statement that was use to prepare the statement.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "paramno", 'type' => Variant, 'desc' => "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."), array('name' => "param", 'type' => Variant, 'desc' => "The value to bind to the parameter."), array('name' => "type", 'type' => Int64, 'value' => "q_PDO_PARAM_STR", 'desc' => "Explicit data type for the parameter using the PDO::PARAM_* constants."))));
DefineFunction(array('name' => "bindparam", 'desc' => "Binds a PHP variable to a corresponding named or question mark placeholder in the SQL statement that was use 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.\n\nMost parameters are input parameters, that is, parameters that are used in a read-only fashion to build up the query. 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.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "paramno", 'type' => Variant, 'desc' => "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."), array('name' => "param", 'type' => Variant | Reference, 'desc' => "Name of the PHP variable to bind to the SQL statement parameter."), array('name' => "type", 'type' => Int64, 'value' => "q_PDO_PARAM_STR", 'desc' => "Explicit data type for the parameter using the PDO::PARAM_* constants. To return an INOUT parameter from a stored procedure, use the bitwise OR operator to set the PDO::PARAM_INPUT_OUTPUT bits for the data_type parameter."), array('name' => "max_value_len", 'type' => Int64, 'value' => "0", 'desc' => "Length of the data type. To indicate that a parameter is an OUT parameter from a stored procedure, you must explicitly set the length."), array('name' => "driver_params", 'type' => Variant, 'value' => "null"))));
DefineFunction(array('name' => "bindcolumn", 'desc' => "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.\n\nSince information about the columns is not always available to PDO until the statement is executed, portable applications should call this function after PDOStatement::execute().\n\nHowever, 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.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "paramno", 'type' => Variant, 'desc' => "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."), array('name' => "param", 'type' => Variant | Reference, 'desc' => "Name of the PHP variable to which the column will be bound."), array('name' => "type", 'type' => Int64, 'value' => "q_PDO_PARAM_STR", 'desc' => "Data type of the parameter, specified by the PDO::PARAM_* constants."), array('name' => "max_value_len", 'type' => Int64, 'value' => "0", 'desc' => "A hint for pre-allocation."), array('name' => "driver_params", 'type' => Variant, 'value' => "null", 'desc' => "Optional parameter(s) for the driver."))));
DefineFunction(array('name' => "rowcount", 'desc' => "PDOStatement::rowCount() returns the number of rows affected by the last DELETE, INSERT, or UPDATE statement executed by the corresponding PDOStatement object.\n\nIf the last SQL statement executed by the associated PDOStatement was a SELECT statement, some databases may return the number of rows returned by that statement. However, this behaviour is not guaranteed for all databases and should not be relied on for portable applications.", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns the number of rows.")));
DefineFunction(array('name' => "errorcode", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Identical to PDO::errorCode(), except that PDOStatement::errorCode() only retrieves error codes for operations performed with PDOStatement objects.")));
DefineFunction(array('name' => "errorinfo", 'flags' => HasDocComment, 'return' => array('type' => VariantVec, 'desc' => "PDOStatement::errorInfo() returns an array of error information about the last operation performed by this statement handle. The array consists of the following fields: Element Information 0 SQLSTATE error code (a five characters alphanumeric identifier defined in the ANSI SQL standard). 1 Driver specific error code. 2 Driver specific error message.")));
DefineFunction(array('name' => "setattribute", 'desc' => "Sets an attribute on the statement. Currently, no generic attributes are set but only driver specific: PDO::ATTR_CURSOR_NAME (Firebird and ODBC specific): Set the name of cursor for UPDATE ... WHERE CURRENT OF.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "attribute", 'type' => Int64), array('name' => "value", 'type' => Variant))));
DefineFunction(array('name' => "getattribute", 'desc' => "Gets an attribute of the statement. Currently, no generic attributes exist but only driver specific: PDO::ATTR_CURSOR_NAME (Firebird and ODBC specific): Get the name of cursor for UPDATE ... WHERE CURRENT OF.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns the attribute value."), 'args' => array(array('name' => "attribute", 'type' => Int64))));
DefineFunction(array('name' => "columncount", 'desc' => "Use PDOStatement::columnCount() to return the number of columns in the result set represented by the PDOStatement object.\n\nIf the PDOStatement object was returned from PDO::query(), the column count is immediately available.\n\nIf the PDOStatement object was returned from PDO::prepare(), an accurate column count will not be available until you invoke PDOStatement::execute().", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns the number of columns in the result set represented by the PDOStatement object. If there is no result set, PDOStatement::columnCount() returns 0.")));
DefineFunction(array('name' => "getcolumnmeta", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns an associative array containing the following values representing the metadata for a single column: Column metadata Name Value native_type The PHP native type used to represent the column value. driver:decl_type The SQL type used to represent the column value in the database. If the column in the result set is the result of a function, this value is not returned by PDOStatement::getColumnMeta(). flags Any flags set for this column. name The name of this column as returned by the database. table The name of this column's table as returned by the database. len The length of this column. Normally -1 for types other than floating point decimals. precision The numeric precision of this column. Normally 0 for types other than floating point decimals. pdo_type The type of this column as represented by the PDO::PARAM_* constants.\n\nReturns FALSE if the requested column does not exist in the result set, or if no result set exists."), 'args' => array(array('name' => "column", 'type' => Int64, 'desc' => "The 0-indexed column in the result set."))));
DefineFunction(array('name' => "setfetchmode", 'flags' => HasDocComment | VariableArguments, 'return' => array('type' => Boolean, 'desc' => "Returns 1 on success or FALSE on failure."), 'args' => array(array('name' => "mode", 'type' => Int64, 'desc' => "The fetch mode must be one of the PDO::FETCH_* constants."))));
DefineFunction(array('name' => "nextrowset", 'desc' => "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.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure.")));
DefineFunction(array('name' => "closecursor", 'desc' => "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.\n\nThis 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.\n\nPDOStatement::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:", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure.")));
DefineFunction(array('name' => "debugdumpparams", 'desc' => "Dumps the informations contained by a prepared statement directly on the output. It will provide the SQL query in use, the number of parameters used (Params), the list of parameters, with their name, type (paramtype) as an integer, their key name or position, the value, and the position in the query (if this is supported by the PDO driver, otherwise, it will be -1).\n\nThis is a debug function, which dump directly the data on the normal output. TipAs 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 string (for example).\n\nThis will only dumps the parameters in the statement at the moment of the dump. Extra parameters are not stored in the statement, and not displayed.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "No value is returned.")));
DefineFunction(array('name' => "current", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "key", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "next", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "rewind", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "valid", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "__wakeup", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "__sleep", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "PDOException", 'parent' => "Exception", 'desc' => "Represents an error raised by PDO. You should not throw a PDOException from your own code. See Exceptions for more information about Exceptions in PHP.", 'flags' => HasDocComment));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
// DefineProperty
//
// array (
// 'name' => name of the property
// 'type' => type of the property
// 'flags' => attributes of the property
// 'desc' => description of the property
// 'note' => additional note about this property's schema
// )
//
// EndClass()
BeginClass(array('name' => "MutableArrayIterator", 'bases' => array('Sweepable'), 'desc' => "Data structure used by the runtime to deal with mutable " . "iteration inside yield generators.", 'flags' => HasDocComment | NoDefaultSweep, 'footer' => <<<EOT
public: union {
char m_u[sizeof(MIterCtx)];
TypedValue m_align;
};
public: bool m_valid;
private: MIterCtx& marr() {
return *(MIterCtx*)(m_u);
}
EOT
));
DefineFunction(array('name' => "__construct", 'return' => array('type' => null), 'args' => array(array('name' => "array", 'type' => Variant | Reference))));
DefineFunction(array('name' => "currentRef", 'return' => array('type' => Variant | Reference)));
DefineFunction(array('name' => "current", 'return' => array('type' => Variant)));
DefineFunction(array('name' => "key", 'return' => array('type' => Variant)));
DefineFunction(array('name' => "next", 'return' => array('type' => null)));
DefineFunction(array('name' => "valid", 'return' => array('type' => Boolean)));
EndClass();
/**
* Explicitly provide a t___invokeCallInfoHelper to
* allow __invoke() to sidestep an extra level of indirection
*/
virtual const CallInfo *t___invokeCallInfoHelper(void *&extra);
String name() const { return String(m_name, CopyString); }
/**
* This is the constructor which is called internally-
* PHP code will never be able to call this constructor
*/
c_Closure(const CallInfo *callInfo, const char *name,
const ObjectStaticCallbacks *cb = &cw_Closure) :
ExtObjectData(cb), m_callInfo(callInfo), m_name(name) {
ASSERT(callInfo);
}
protected:
virtual bool php_sleep(Variant &ret);
private:
const CallInfo *m_callInfo;
const char *m_name;
EOT
));
DefineFunction(array('name' => '__construct', 'args' => array(), 'return' => array('type' => null)));
DefineFunction(array('name' => '__invoke', 'flags' => VariableArguments, 'return' => array('type' => Variant)));
DefineFunction(array('name' => '__clone', 'return' => array('type' => Variant)));
EndClass();
BeginClass(array('name' => "DummyClosure", 'desc' => "Represents an invalid closure which will fatal when used."));
DefineFunction(array('name' => '__construct', 'args' => array(), 'return' => array('type' => null)));
EndClass();
// DefineProperty
//
// array (
// 'name' => name of the property
// 'type' => type of the property
// 'flags' => attributes of the property
// 'desc' => description of the property
// 'note' => additional note about this property's schema
// )
//
// EndClass()
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "Memcache", 'bases' => array('Sweepable'), 'desc' => "Represents a connection to a set of memcache servers.", 'flags' => HasDocComment, 'footer' => <<<EOT
private:
memcached_st m_memcache;
int m_compress_threshold;
double m_min_compress_savings;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "connect", 'desc' => "Memcache::connect() establishes a connection to the memcached server. The connection, which was opened using Memcache::connect() will be automatically closed at the end of script execution. Also you can close it with Memcache::close(). Also you can use memcache_connect() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "host", 'type' => String, 'desc' => "Point to the host where memcached is listening for connections. This parameter may also specify other transports like unix:///path/to/memcached.sock to use UNIX domain sockets, in this case port must also be set to 0."), array('name' => "port", 'type' => Int32, 'value' => "0", 'desc' => "Point to the port where memcached is listening for connections. Set this parameter to 0 when using UNIX domain sockets."), array('name' => "timeout", 'type' => Int32, 'value' => "0", 'desc' => "Value in seconds which will be used for connecting to the daemon. Think twice before changing the default value of 1 second - you can lose all the advantages of caching if your connection is too slow."), array('name' => "timeoutms", 'type' => Int32, 'value' => "0"))));
DefineFunction(array('name' => "pconnect", 'desc' => "Memcache::pconnect() is similar to Memcache::connect() with the difference, that the connection it establishes is persistent. This connection is not closed after the end of script execution and by Memcache::close() function. Also you can use memcache_pconnect() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "host", 'type' => String, 'desc' => "Point to the host where memcached is listening for connections. This parameter may also specify other transports like unix:///path/to/memcached.sock to use UNIX domain sockets, in this case port must also be set to 0."), array('name' => "port", 'type' => Int32, 'value' => "0", 'desc' => "Point to the port where memcached is listening for connections. Set this parameter to 0 when using UNIX domain sockets."), array('name' => "timeout", 'type' => Int32, 'value' => "0", 'desc' => "Value in seconds which will be used for connecting to the daemon. Think twice before changing the default value of 1 second - you can lose all the advantages of caching if your connection is too slow."), array('name' => "timeoutms", 'type' => Int32, 'value' => "0"))));
DefineFunction(array('name' => "add", 'desc' => "Memcache::add() stores variable var with key only if such key doesn't exist at the server yet. Also you can use memcache_add() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure. Returns FALSE if such key already exist. For the rest Memcache::add() behaves similarly to Memcache::set()."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key that will be associated with the item."), array('name' => "var", 'type' => Variant, 'desc' => "The variable to store. Strings and integers are stored as is, other types are stored serialized."), array('name' => "flag", 'type' => Int32, 'value' => "0", 'desc' => "Use MEMCACHE_COMPRESSED to store the item compressed (uses zlib)."), array('name' => "expire", 'type' => Int32, 'value' => "0", 'desc' => "Expiration time of the item. If it's equal to zero, the item will never expire. You can also use Unix timestamp or a number of seconds starting from current time, but in the latter case the number of seconds may not exceed 2592000 (30 days)."))));
DefineFunction(array('name' => "set", 'desc' => "Memcache::set() stores an item var with key on the memcached server. Parameter expire is expiration time in seconds. If it's 0, the item never expires (but memcached server doesn't guarantee this item to be stored all the time, it could be deleted from the cache to make place for other items). You can use MEMCACHE_COMPRESSED constant as flag value if you want to use on-the-fly compression (uses zlib).\n\nRemember that resource variables (i.e. file and connection descriptors) cannot be stored in the cache, because they cannot be adequately represented in serialized state. Also you can use memcache_set() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key that will be associated with the item."), array('name' => "var", 'type' => Variant, 'desc' => "The variable to store. Strings and integers are stored as is, other types are stored serialized."), array('name' => "flag", 'type' => Int32, 'value' => "0", 'desc' => "Use MEMCACHE_COMPRESSED to store the item compressed (uses zlib)."), array('name' => "expire", 'type' => Int32, 'value' => "0", 'desc' => "Expiration time of the item. If it's equal to zero, the item will never expire. You can also use Unix timestamp or a number of seconds starting from current time, but in the latter case the number of seconds may not exceed 2592000 (30 days)."))));
DefineFunction(array('name' => "replace", 'desc' => "Memcache::replace() should be used to replace value of existing item with key. In case if item with such key doesn't exists, Memcache::replace() returns FALSE. For the rest Memcache::replace() behaves similarly to Memcache::set(). Also you can use memcache_replace() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key that will be associated with the item."), array('name' => "var", 'type' => Variant, 'desc' => "The variable to store. Strings and integers are stored as is, other types are stored serialized."), array('name' => "flag", 'type' => Int32, 'value' => "0", 'desc' => "Use MEMCACHE_COMPRESSED to store the item compressed (uses zlib)."), array('name' => "expire", 'type' => Int32, 'value' => "0", 'desc' => "Expiration time of the item. If it's equal to zero, the item will never expire. You can also use Unix timestamp or a number of seconds starting from current time, but in the latter case the number of seconds may not exceed 2592000 (30 days)."))));
DefineFunction(array('name' => "get", 'desc' => "Memcache::get() returns previously stored data if an item with such key exists on the server at this moment.\n\nYou can pass array of keys to Memcache::get() to get array of values. The result array will contain only found key-value pairs.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns the string associated with the key or FALSE on failure or if such key was not found."), 'args' => array(array('name' => "key", 'type' => Variant, 'desc' => "The key or array of keys to fetch."), array('name' => "flags", 'type' => Variant | Reference, 'value' => "null", 'desc' => "If present, flags fetched along with the values will be written to this parameter. These flags are the same as the ones given to for example Memcache::set(). The lowest byte of the int is reserved for pecl/memcache internal usage (e.g. to indicate compression and serialization status).")), 'taint_observer' => array('set_mask' => "TAINT_BIT_ALL", 'clear_mask' => "TAINT_BIT_NONE")));
DefineFunction(array('name' => "delete", 'desc' => "Memcache::delete() deletes item with the key. If parameter timeout is specified, the item will expire after timeout seconds. Also you can use memcache_delete() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key associated with the item to delete."), array('name' => "expire", 'type' => Int32, 'value' => "0", 'desc' => "Execution time of the item. If it's equal to zero, the item will be deleted right away whereas if you set it to 30, the item will be deleted in 30 seconds."))));
DefineFunction(array('name' => "increment", 'desc' => "Memcache::increment() increments value of an item by the specified value. If item specified by key was not numeric and cannot be converted to a number, it will change its value to value. Memcache::increment() does not create an item if it doesn't already exist.\n\nDo not use Memcache::increment() with items that have been stored compressed because subsequent calls to Memcache::get() will fail. Also you can use memcache_increment() function.", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns new items value on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "Key of the item to increment."), array('name' => "offset", 'type' => Int32, 'value' => "1", 'desc' => "Increment the item by value."))));
DefineFunction(array('name' => "decrement", 'desc' => "Memcache::decrement() decrements value of the item by value. Similarly to Memcache::increment(), current value of the item is being converted to numerical and after that value is substracted.\n\nNew item's value will not be less than zero.\n\nDo not use Memcache::decrement() with item, which was stored compressed, because consequent call to Memcache::get() will fail. Memcache::decrement() does not create an item if it didn't exist. Also you can use memcache_decrement() function.", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns item's new value on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "Key of the item do decrement."), array('name' => "offset", 'type' => Int32, 'value' => "1", 'desc' => "Decrement the item by value."))));
DefineFunction(array('name' => "getversion", 'desc' => "Memcache::getVersion() returns a string with server's version number. Also you can use memcache_get_version() function.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns a string of server version number or FALSE on failure.")));
DefineFunction(array('name' => "flush", 'desc' => "Memcache::flush() immediately invalidates all existing items. Memcache::flush() doesn't actually free any resources, it only marks all the items as expired, so occupied memory will be overwritten by new items. Also you can use memcache_flush() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "expire", 'type' => Int32, 'value' => "0"))));
BeginClass(array('name' => "Memcached", 'bases' => array('Sweepable'), 'desc' => "Represents a connection to a set of memcached servers.", 'flags' => HasDocComment, 'footer' => <<<EOT
private:
class Impl {
public:
Impl();
~Impl();
memcached_st memcached;
bool compression;
int serializer;
int rescode;
};
typedef boost::shared_ptr<Impl> ImplPtr;
ImplPtr m_impl;
bool handleError(memcached_return status);
void toPayload(CVarRef value, std::vector<char> &payload, uint32 &flags);
bool toObject(Variant& value, const memcached_result_st &result);
memcached_return doCacheCallback(CVarRef callback, CStrRef key,
Variant& value);
bool getMultiImpl(CStrRef server_key, CArrRef keys, bool enableCas,
Array *returnValue);
bool fetchImpl(memcached_result_st &result, Array &item);
typedef memcached_return_t (*SetOperation)(memcached_st *,
const char *, size_t, const char *, size_t, const char *, size_t,
time_t, uint32_t);
bool setOperationImpl(SetOperation op, CStrRef server_key,
CStrRef key, CVarRef value, int expiration);
typedef memcached_return_t (*IncDecOperation)(memcached_st *,
const char *, size_t, uint32_t, uint64_t *);
Variant incDecOperationImpl(IncDecOperation op, CStrRef key, int64 offset);
typedef std::map<std::string, ImplPtr> ImplMap;
static DECLARE_THREAD_LOCAL(ImplMap, s_persistentMap);
EOT
));
public: Variant m_value;
public: int64 m_type;
public: String m_stype;
public: String m_ns;
public: String m_name;
public: String m_namens;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "data", 'type' => Variant), array('name' => "type", 'type' => Variant), array('name' => "type_name", 'type' => String, 'value' => "null_string"), array('name' => "type_namespace", 'type' => String, 'value' => "null_string"), array('name' => "node_name", 'type' => String, 'value' => "null_string"), array('name' => "node_namespace", 'type' => String, 'value' => "null_string"))));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "SoapParam", 'desc' => "Represents parameter to a SOAP call.", 'flags' => HasDocComment, 'footer' => <<<EOT
public: String m_name;
public: String m_data;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "data", 'type' => Variant), array('name' => "name", 'type' => String))));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "SoapHeader", 'desc' => "Represents a SOAP header.", 'flags' => HasDocComment, 'footer' => <<<EOT
public: String m_namespace;
public: String m_name;
public: Variant m_data;
public: bool m_mustUnderstand;
public: Variant m_actor;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "ns", 'type' => String), array('name' => "name", 'type' => String), array('name' => "data", 'type' => Variant, 'value' => "null"), array('name' => "mustunderstand", 'type' => Boolean, 'value' => "false"), array('name' => "actor", 'type' => Variant, 'value' => "null"))));
EndClass();
),
));
EndClass();
BeginClass(
array(
'name' => 'GeneratorClosure',
'parent' => 'Closure',
'footer' => <<<EOT
public:
/**
* This is the constructor which is called internally-
* PHP code will never be able to call this constructor
*/
c_GeneratorClosure(
const CallInfo *callInfo,
void *extraData,
CArrRef vars) :
c_Closure(callInfo, extraData), m_vars(vars) {}
public:
Array m_vars; /* use variables */
Array m_statics; /* static variables */
EOT
,
)
);
DefineFunction(
array(
'name' => '__construct',
'args' => array(),
Variant value;
};
public: BoundParamPtrVec m_bound_params;
EOT
));
DefineFunction(array('name' => "__construct", 'return' => array('type' => null), 'args' => array(array('name' => "dbobject", 'type' => Object), array('name' => "statement", 'type' => String))));
DefineFunction(array('name' => "paramcount", 'desc' => "Returns the number of parameters within the prepared statement.", 'return' => array('type' => Int64, 'desc' => "Returns the number of parameters within the prepared statement.")));
DefineFunction(array('name' => "close", 'desc' => "Closes the prepared statement.", 'return' => array('type' => Boolean, 'desc' => "Returns TRUE")));
DefineFunction(array('name' => "reset", 'desc' => "Resets the prepared statement to its state prior to execution. All bindings remain intact after reset.", 'return' => array('type' => Boolean, 'desc' => "Returns TRUE if the statement is successfully reset, FALSE on failure.")));
DefineFunction(array('name' => "clear", 'desc' => "Clears all current bound parameters.", 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on successful clearing of bound parameters, FALSE on failure.")));
DefineFunction(array('name' => "bindparam", 'desc' => "Binds a parameter to a statement variable.", 'return' => array('type' => Boolean, 'desc' => "Returns TRUE if the parameter is bound to the statement variable, FALSE on failure."), 'args' => array(array('name' => "name", 'type' => Variant, 'desc' => "An string identifying the statement variable to which the parameter should be bound."), array('name' => "parameter", 'type' => Variant | Reference, 'desc' => "The parameter to bind to a statement variable."), array('name' => "type", 'type' => Int64, 'value' => "k_SQLITE3_TEXT", 'desc' => "The data type of the parameter to bind.\nSQLITE3_INTEGER: The value is a signed integer, stored in 1, 2, 3, 4, 6, or 8 bytes depending on the magnitude of the value.\nSQLITE3_FLOAT: The value is a floating point value, stored as an 8-byte IEEE floating point number.\nSQLITE3_TEXT: The value is a text string, stored using the database encoding (UTF-8, UTF-16BE or UTF-16-LE).\nSQLITE3_BLOB: The value is a blob of data, stored exactly as it was input.\nSQLITE3_NULL: The value is a NULL value."))));
DefineFunction(array('name' => "bindvalue", 'desc' => "Binds the value of a parameter to a statement variable.", 'return' => array('type' => Boolean, 'desc' => "Returns TRUE if the value is bound to the statement variable, FALSE on failure."), 'args' => array(array('name' => "name", 'type' => Variant, 'desc' => "An string identifying the statement variable to which the value should be bound."), array('name' => "parameter", 'type' => Variant, 'desc' => "The value to bind to a statement variable."), array('name' => "type", 'type' => Int64, 'value' => "k_SQLITE3_TEXT", 'desc' => "The data type of the value to bind.\nSQLITE3_INTEGER: The value is a signed integer, stored in 1, 2, 3, 4, 6, or 8 bytes depending on the magnitude of the value.\nSQLITE3_FLOAT: The value is a floating point value, stored as an 8-byte IEEE floating point number.\nSQLITE3_TEXT: The value is a text string, stored using the database encoding (UTF-8, UTF-16BE or UTF-16-LE).\nSQLITE3_BLOB: The value is a blob of data, stored exactly as it was input.\nSQLITE3_NULL: The value is a NULL value."))));
DefineFunction(array('name' => "execute", 'desc' => "Executes a prepared statement and returns a result set object.", 'return' => array('type' => Variant, 'desc' => "Returns an SQLite3Result object on successful execution of the prepared statement, FALSE on failure.")));
DefineFunction(array('name' => "__destruct", 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "sqlite3result", 'desc' => "A class that handles result sets for the SQLite 3 extension.", 'footer' => <<<EOT
public: void validate() const;
public: sp_sqlite3stmt m_stmt;
EOT
));
DefineFunction(array('name' => "__construct", 'return' => array('type' => null)));
DefineFunction(array('name' => "numcolumns", 'desc' => "Returns the number of columns in the result set.", 'return' => array('type' => Int64, 'desc' => "Returns the number of columns in the result set.")));
DefineFunction(array('name' => "columnname", 'desc' => "Returns the name of the column specified by the column_number.", 'return' => array('type' => String, 'desc' => "Returns the string name of the column identified by column_number."), 'args' => array(array('name' => "column", 'type' => Int64, 'desc' => "The numeric zero-based index of the column."))));
DefineFunction(array('name' => "columntype", 'desc' => "Returns the type of the column identified by column_number.", 'return' => array('type' => Int64, 'desc' => "Returns the data type index of the column identified by column_number (one of SQLITE3_INTEGER, SQLITE3_FLOAT, SQLITE3_TEXT, SQLITE3_BLOB, or SQLITE3_NULL)."), 'args' => array(array('name' => "column", 'type' => Int64, 'desc' => "The numeric zero-based index of the column."))));
DefineFunction(array('name' => "fetcharray", 'desc' => "Fetches a result row as an associative or numerically indexed array or both. By default, fetches as both.", 'return' => array('type' => Variant, 'desc' => "Returns a result row as an associatively or numerically indexed array or both."), 'args' => array(array('name' => "mode", 'type' => Int64, 'value' => "k_SQLITE3_BOTH", 'desc' => "Controls how the next row will be returned to the caller. This value must be one of either SQLITE3_ASSOC, SQLITE3_NUM, or SQLITE3_BOTH.\nSQLITE3_ASSOC: returns an array indexed by column name as returned in the corresponding result set\nSQLITE3_NUM: returns an array indexed by column number as returned in the corresponding result set, starting at column 0\nSQLITE3_BOTH: returns an array indexed by both column name and number as returned in the corresponding result set, starting at column 0"))));
DefineFunction(array('name' => "reset", 'return' => array('type' => Boolean)));
DefineFunction(array('name' => "finalize", 'desc' => "Closes the result set.", 'return' => array('type' => Boolean, 'desc' => "Returns TRUE.")));
DefineFunction(array('name' => "__destruct", 'return' => array('type' => Variant)));
EndClass();
// 'desc' => description of the property
// 'note' => additional note about this property's schema
// )
//
// EndClass()
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "EncodingDetector", 'desc' => "Guesses the encoding of an array of bytes in an unknown encoding (see http://icu-project.org/apiref/icu4c/ucsdet_8h.html)", 'flags' => HasDocComment, 'footer' => <<<EOT
private: UCharsetDetector *m_encoding_detector;
EOT
));
DefineFunction(array('name' => "__construct", 'desc' => "Creates an encoding detector.", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "setText", 'desc' => "Sets the input byte array whose encoding is to be guessed.", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "text", 'type' => String, 'desc' => "A byte array whose encoding is to be guessed."))));
DefineFunction(array('name' => "setDeclaredEncoding", 'desc' => "If the user provided an encoding in metadata (like an HTTP or XML declaration), this can be used as an additional hint to the detector.", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "text", 'type' => String, 'desc' => "Possible encoding for the byte array obtained from associated metadata"))));
DefineFunction(array('name' => "detect", 'desc' => "Returns an EncodingMatch object containing the best guess for the encoding of the byte array", 'flags' => HasDocComment, 'return' => array('type' => Object, 'desc' => "EncodingMatch object for the best guess of the encoding of the byte array")));
DefineFunction(array('name' => "detectAll", 'desc' => "Returns an array of EncodingMatch objects containing all guesses for the encoding of the byte array", 'flags' => HasDocComment, 'return' => array('type' => VariantVec, 'desc' => "Array of EncodingMatch objects for all guesses of the encoding of the byte array")));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "EncodingMatch", 'desc' => "Result of detecting the encoding of an array of bytes", 'flags' => HasDocComment, 'footer' => <<<EOT
public: const UCharsetMatch *m_encoding_match;
private: void validate();
EOT
));
DefineFunction(array('name' => "__construct", 'desc' => "Internal only: Creates an encoding match.", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "isValid", 'desc' => "Checks if the encoding match succeeded.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "true if the match succeeded, false otherwise")));
DefineFunction(array('name' => "getEncoding", 'desc' => "Gets the name of the detected encoding", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "The name of the detected encoding")));
DefineFunction(array('name' => "getConfidence", 'desc' => "Gets the confidence number of the encoding match", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Confidence number from 0 (no confidence) to 100 (complete confidence)")));
DefineFunction(array('name' => "getLanguage", 'desc' => "Gets a rough guess at the language of the encoded bytes", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "A rough guess at the language of the encoded bytes")));
DefineFunction(array('name' => "getUTF8", 'desc' => "Gets the UTF-8 encoded version of the encoded byte array", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "The result of converting the bytes to UTF-8 with the detected encoding")));
EndClass();
Variant value;
};
public: BoundParamPtrVec m_bound_params;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "dbobject", 'type' => Object), array('name' => "statement", 'type' => String))));
DefineFunction(array('name' => "paramcount", 'desc' => "Returns the number of parameters within the prepared statement.", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns the number of parameters within the prepared statement.")));
DefineFunction(array('name' => "close", 'desc' => "Closes the prepared statement.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE")));
DefineFunction(array('name' => "reset", 'desc' => "Resets the prepared statement to its state prior to execution. All bindings remain intact after reset.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE if the statement is successfully reset, FALSE on failure.")));
DefineFunction(array('name' => "clear", 'desc' => "Clears all current bound parameters.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on successful clearing of bound parameters, FALSE on failure.")));
DefineFunction(array('name' => "bindparam", 'desc' => "Binds a parameter to a statement variable.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE if the parameter is bound to the statement variable, FALSE on failure."), 'args' => array(array('name' => "name", 'type' => Variant, 'desc' => "An string identifying the statement variable to which the parameter should be bound."), array('name' => "parameter", 'type' => Variant | Reference, 'desc' => "The parameter to bind to a statement variable."), array('name' => "type", 'type' => Int64, 'value' => "k_SQLITE3_TEXT", 'desc' => "The data type of the parameter to bind.\n\nSQLITE3_INTEGER: The value is a signed integer, stored in 1, 2, 3, 4, 6, or 8 bytes depending on the magnitude of the value.\n\nSQLITE3_FLOAT: The value is a floating point value, stored as an 8-byte IEEE floating point number.\n\nSQLITE3_TEXT: The value is a text string, stored using the database encoding (UTF-8, UTF-16BE or UTF-16-LE).\n\nSQLITE3_BLOB: The value is a blob of data, stored exactly as it was input.\n\nSQLITE3_NULL: The value is a NULL value."))));
DefineFunction(array('name' => "bindvalue", 'desc' => "Binds the value of a parameter to a statement variable.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE if the value is bound to the statement variable, FALSE on failure."), 'args' => array(array('name' => "name", 'type' => Variant, 'desc' => "An string identifying the statement variable to which the value should be bound."), array('name' => "parameter", 'type' => Variant, 'desc' => "The value to bind to a statement variable."), array('name' => "type", 'type' => Int64, 'value' => "k_SQLITE3_TEXT", 'desc' => "The data type of the value to bind.\n\nSQLITE3_INTEGER: The value is a signed integer, stored in 1, 2, 3, 4, 6, or 8 bytes depending on the magnitude of the value.\n\nSQLITE3_FLOAT: The value is a floating point value, stored as an 8-byte IEEE floating point number.\n\nSQLITE3_TEXT: The value is a text string, stored using the database encoding (UTF-8, UTF-16BE or UTF-16-LE).\n\nSQLITE3_BLOB: The value is a blob of data, stored exactly as it was input.\n\nSQLITE3_NULL: The value is a NULL value."))));
DefineFunction(array('name' => "execute", 'desc' => "Executes a prepared statement and returns a result set object.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns an SQLite3Result object on successful execution of the prepared statement, FALSE on failure.")));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "SQLite3Result", 'desc' => "A class that handles result sets for the SQLite 3 extension.", 'flags' => HasDocComment, 'footer' => <<<EOT
public: void validate() const;
public: p_SQLite3Stmt m_stmt;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "numcolumns", 'desc' => "Returns the number of columns in the result set.", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns the number of columns in the result set.")));
DefineFunction(array('name' => "columnname", 'desc' => "Returns the name of the column specified by the column_number.", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "Returns the string name of the column identified by column_number."), 'args' => array(array('name' => "column", 'type' => Int64, 'desc' => "The numeric zero-based index of the column."))));
DefineFunction(array('name' => "columntype", 'desc' => "Returns the type of the column identified by column_number.", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns the data type index of the column identified by column_number (one of SQLITE3_INTEGER, SQLITE3_FLOAT, SQLITE3_TEXT, SQLITE3_BLOB, or SQLITE3_NULL)."), 'args' => array(array('name' => "column", 'type' => Int64, 'desc' => "The numeric zero-based index of the column."))));
DefineFunction(array('name' => "fetcharray", 'desc' => "Fetches a result row as an associative or numerically indexed array or both. By default, fetches as both.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns a result row as an associatively or numerically indexed array or both."), 'args' => array(array('name' => "mode", 'type' => Int64, 'value' => "k_SQLITE3_BOTH", 'desc' => "Controls how the next row will be returned to the caller. This value must be one of either SQLITE3_ASSOC, SQLITE3_NUM, or SQLITE3_BOTH.\n\nSQLITE3_ASSOC: returns an array indexed by column name as returned in the corresponding result set\n\nSQLITE3_NUM: returns an array indexed by column number as returned in the corresponding result set, starting at column 0\n\nSQLITE3_BOTH: returns an array indexed by both column name and number as returned in the corresponding result set, starting at column 0"))));
DefineFunction(array('name' => "reset", 'flags' => HasDocComment, 'return' => array('type' => Boolean)));
DefineFunction(array('name' => "finalize", 'desc' => "Closes the result set.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE.")));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
//
// array (
// 'name' => name of the property
// 'type' => type of the property
// 'flags' => attributes of the property
// 'desc' => description of the property
// 'note' => additional note about this property's schema
// )
//
// EndClass()
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "MemcachePool", 'bases' => array('Sweepable'), 'desc' => "Represents a connection to a set of memcache servers.", 'flags' => HasDocComment, 'footer' => <<<EOT
public: void close();
private:
bool prefetch(CVarRef key);
bool check_memcache_return(memcached_st * st, memcached_return_t ret,
String key = "", char *default_msg = "");
void exec_failure_callback(const char * hostname, int tcp_port, int udp_port,
memcached_return_t ret, const char * error, Array backtrace);
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "getstoragememcache", 'desc' => "MemcachePool::getstoragememcache() is a static member to get\n\t\tonly one instance per storage_id and thread. The timestamp is used to know\n\t\tif the stored object have old configuration and need to be recreated", 'flags' => IsStatic | HasDocComment, 'return' => array('type' => Object, 'desc' => "Returns a MemcachePool Object or NULL if we need to create\n\t\t\tnew one (next call will return a new Object)."), 'args' => array(array('name' => "storage_id", 'type' => Int32, 'desc' => "Number of the storage id (used to get only one instance per\n\t\t\t\tstorage)."), array('name' => "timestamp", 'type' => Int32, 'desc' => "Time of the last configuration change."), array('name' => "empty", 'type' => Variant | Reference, 'desc' => "This parameter is needed to indicate if the memcached\n\t\t\t\tobject is new and needs to be populated with the memcached servers"), array('name' => "persistent", 'type' => Boolean, 'value' => "false", 'desc' => "Defines if the tcp connections should be persistent"))));
DefineFunction(array('name' => "connect", 'desc' => "MemcachePool::connect() establishes a connection to the memcached\n\t\tserver. The connection, which was opened using MemcachePool::connect() will be\n\t\tautomatically closed at the end of script execution. Also you can close it\n\t\twith MemcachePool::close(). Also you can use memcache_connect() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "host", 'type' => String, 'desc' => "Point to the host where memcached is listening for\n\t\t\t\tconnections. This parameter may also specify other transports like\n\t\t\t\tunix:///path/to/memcached.sock to use UNIX domain sockets, in this case\n\t\t\t\tport must also be set to 0."), array('name' => "port", 'type' => Int32, 'value' => "0", 'desc' => "Point to the port where memcached is listening for\n\t\t\t\tconnections. Set this parameter to 0 when using UNIX domain sockets."), array('name' => "timeout", 'type' => Int32, 'value' => "0", 'desc' => "Value in seconds which will be used for connecting to the\n\t\t\t\tdaemon. Think twice before changing the default value of 1 second - you\n\t\t\t\tcan lose all the advantages of caching if your connection is too slow."), array('name' => "timeoutms", 'type' => Int32, 'value' => "0"))));
DefineFunction(array('name' => "pconnect", 'desc' => "MemcachePool::pconnect() is similar to MemcachePool::connect() with the\n\t\tdifference, that the connection it establishes is persistent. This\n\t\tconnection is not closed after the end of script execution and by\n\t\tMemcachePool::close() function. Also you can use memcache_pconnect() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "host", 'type' => String, 'desc' => "Point to the host where memcached is listening for\n\t\t\t\tconnections. This parameter may also specify other transports like\n\t\t\t\tunix:///path/to/memcached.sock to use UNIX domain sockets, in this case\n\t\t\t\tport must also be set to 0."), array('name' => "port", 'type' => Int32, 'value' => "0", 'desc' => "Point to the port where memcached is listening for\n\t\t\t\tconnections. Set this parameter to 0 when using UNIX domain sockets."), array('name' => "timeout", 'type' => Int32, 'value' => "0", 'desc' => "Value in seconds which will be used for connecting to the\n\t\t\t\tdaemon. Think twice before changing the default value of 1 second - you\n\t\t\t\tcan lose all the advantages of caching if your connection is too slow."), array('name' => "timeoutms", 'type' => Int32, 'value' => "0"))));
DefineFunction(array('name' => "add", 'desc' => "MemcachePool::add() stores variable var with key only if such key\n\t\tdoesn't exist at the server yet. Also you can use memcache_add() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure. Returns FALSE if\n\t\t\tsuch key already exist. For the rest MemcachePool::add() behaves similarly to\n\t\t\tMemcachePool::set()."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key that will be associated with the item."), array('name' => "var", 'type' => Variant, 'desc' => "The variable to store. Strings and integers are stored as\n\t\t\t\tis, other types are stored serialized."), array('name' => "flag", 'type' => Int32, 'value' => "0", 'desc' => "Use MEMCACHE_COMPRESSED to store the item compressed (uses\n\t\t\t\tzlib)."), array('name' => "expire", 'type' => Int32, 'value' => "0", 'desc' => "Expiration time of the item. If it's equal to zero, the\n\t\t\t\titem will never expire. You can also use Unix timestamp or a number of\n\t\t\t\tseconds starting from current time, but in the latter case the number of\n\t\t\t\tseconds may not exceed 2592000 (30 days)."))));
DefineFunction(array('name' => "cas", 'desc' => "MemcachePool::cas() have the same behaviour as set, but only\n\t\tchanges the item if its was unchanged from the last time the value was\n\t\tobtained. This is checked using CAS parameter, obtained when calling get", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key that will be associated with the item."), array('name' => "var", 'type' => Variant, 'desc' => "The variable to store. Strings and integers are stored as\n\t\t\t\tis, other types are stored serialized."), array('name' => "flag", 'type' => Int32, 'desc' => "Use MEMCACHE_COMPRESSED to store the item compressed (uses\n\t\t\t\tzlib)."), array('name' => "expire", 'type' => Int32, 'desc' => "Expiration time of the item. If it's equal to zero, the\n\t\t\t\titem will never expire. You can also use Unix timestamp or a number of\n\t\t\t\tseconds starting from current time, but in the latter case the number of\n\t\t\t\tseconds may not exceed 2592000 (30 days)."), array('name' => "cas_token", 'type' => Double, 'desc' => "Unique value associated with the existing item. Generated\n\t\t\t\tby memcache."))));
DefineFunction(array('name' => "set", 'desc' => "MemcachePool::set() stores an item var with key on the memcached\n\t\tserver. Parameter expire is expiration time in seconds. If it's 0, the item\n\t\tnever expires (but memcached server doesn't guarantee this item to be stored\n\t\tall the time, it could be deleted from the cache to make place for other\n\t\titems). You can use MEMCACHE_COMPRESSED constant as flag value if you want\n\t\tto use on-the-fly compression (uses zlib).\n\nRemember that resource\n\t\tvariables (i.e. file and connection descriptors) cannot be stored in the\n\t\tcache, because they cannot be adequately represented in serialized state.\n\t\tAlso you can use memcache_set() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key that will be associated with the item."), array('name' => "var", 'type' => Variant, 'desc' => "The variable to store. Strings and integers are stored as\n\t\t\t\tis, other types are stored serialized."), array('name' => "flag", 'type' => Int32, 'value' => "0", 'desc' => "Use MEMCACHE_COMPRESSED to store the item compressed (uses\n\t\t\t\tzlib)."), array('name' => "expire", 'type' => Int32, 'value' => "0", 'desc' => "Expiration time of the item. If it's equal to zero, the\n\t\t\t\titem will never expire. You can also use Unix timestamp or a number of\n\t\t\t\tseconds starting from current time, but in the latter case the number of\n\t\t\t\tseconds may not exceed 2592000 (30 days)."))));
DefineFunction(array('name' => "replace", 'desc' => "MemcachePool::replace() should be used to replace value of existing\n\t\titem with key. In case if item with such key doesn't exists,\n\t\tMemcachePool::replace() returns FALSE. For the rest MemcachePool::replace() behaves\n\t\tsimilarly to MemcachePool::set(). Also you can use memcache_replace()\n\t\tfunction.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key that will be associated with the item."), array('name' => "var", 'type' => Variant, 'desc' => "The variable to store. Strings and integers are stored as\n\t\t\t\tis, other types are stored serialized."), array('name' => "flag", 'type' => Int32, 'value' => "0", 'desc' => "Use MEMCACHE_COMPRESSED to store the item compressed (uses\n\t\t\t\tzlib)."), array('name' => "expire", 'type' => Int32, 'value' => "0", 'desc' => "Expiration time of the item. If it's equal to zero, the\n\t\t\t\titem will never expire. You can also use Unix timestamp or a number of\n\t\t\t\tseconds starting from current time, but in the latter case the number of\n\t\t\t\tseconds may not exceed 2592000 (30 days)."))));
DefineFunction(array('name' => "get", 'desc' => "MemcachePool::get() returns previously stored data if an item with\n\t\tsuch key exists on the server at this moment.\n\nYou can pass array of keys\n\t\tto MemcachePool::get() to get array of values. The result array will contain\n\t\tonly found key-value pairs.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns the string associated with the key or FALSE on\n\t\t\tfailure or if such key was not found."), 'args' => array(array('name' => "key", 'type' => Variant, 'desc' => "The key or array of keys to fetch."), array('name' => "flags", 'type' => Variant | Reference, 'value' => "null", 'desc' => "If present, flags fetched along with the values will be\n\t\t\t\twritten to this parameter. These flags are the same as the ones given to\n\t\t\t\tfor example MemcachePool::set(). The lowest byte of the int is reserved for\n\t\t\t\tpecl/memcache internal usage (e.g. to indicate compression and\n\t\t\t\tserialization status)."), array('name' => "cas", 'type' => Variant | Reference, 'value' => "null", 'desc' => "If present, cas key wil be fetched along with the values\n\t\t\t\tand will be written to this parameter."))));
DefineFunction(array('name' => "prefetch", 'desc' => "MemcachePool::prefetch() prefetch some keys, without actual\n\t\treturning the values of those keys. You need to call later to get, in order\n\t\tto fetch the results.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => Variant, 'desc' => "The key or array of keys to fetch."))));
DefineFunction(array('name' => "delete", 'desc' => "MemcachePool::delete() deletes item with the key. If parameter\n\t\ttimeout is specified, the item will expire after timeout seconds. Also you\n\t\tcan use memcache_delete() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key associated with the item to delete."), array('name' => "expire", 'type' => Int32, 'value' => "0", 'desc' => "Execution time of the item. If it's equal to zero, the item\n\t\t\t\twill be deleted right away whereas if you set it to 30, the item will be\n\t\t\t\tdeleted in 30 seconds."))));
DefineFunction(array('name' => 'key', 'return' => array('type' => Int64)));
DefineFunction(array('name' => 'next', 'return' => array('type' => null)));
DefineFunction(array('name' => 'rewind', 'return' => array('type' => null)));
DefineFunction(array('name' => 'valid', 'return' => array('type' => Boolean)));
DefineFunction(array('name' => 'send', 'return' => array('type' => null), 'args' => array(array('name' => 'v', 'type' => Variant))));
DefineFunction(array('name' => 'raise', 'return' => array('type' => null), 'args' => array(array('name' => 'v', 'type' => Variant))));
DefineFunction(array('name' => 'raised', 'return' => array('type' => null)));
DefineFunction(array('name' => 'receive', 'return' => array('type' => Variant)));
DefineFunction(array('name' => 'getOrigFuncName', 'return' => array('type' => String)));
DefineProperty(array('name' => 'obj', 'type' => Object, 'flags' => IsPrivate));
DefineProperty(array('name' => 'args', 'type' => VariantVec, 'flags' => IsPrivate));
DefineProperty(array('name' => 'label', 'type' => Int64, 'flags' => IsPrivate));
DefineProperty(array('name' => 'index', 'type' => Int64, 'flags' => IsPrivate));
DefineProperty(array('name' => 'value', 'type' => Variant, 'flags' => IsPrivate));
DefineProperty(array('name' => 'received', 'type' => Variant, 'flags' => IsPrivate));
DefineProperty(array('name' => 'origFuncName', 'type' => String, 'flags' => IsPrivate));
DefineProperty(array('name' => 'called_class', 'type' => String, 'flags' => IsPrivate));
DefineProperty(array('name' => 'done', 'type' => Boolean, 'flags' => IsPrivate));
DefineProperty(array('name' => 'running', 'type' => Boolean, 'flags' => IsPrivate));
DefineFunction(array('name' => '__clone', 'return' => array('type' => Variant)));
EndClass();
BeginClass(array('name' => 'GenericContinuation', 'parent' => 'Continuation', 'footer' => <<<EOT
public:
LVariableTable m_statics;
EOT
));
DefineFunction(array('name' => '__construct', 'return' => array('type' => null), 'args' => array(array('name' => 'func', 'type' => Int64), array('name' => 'extra', 'type' => Int64), array('name' => 'isMethod', 'type' => Boolean), array('name' => 'origFuncName', 'type' => String), array('name' => 'vars', 'type' => VariantMap), array('name' => 'obj', 'type' => Variant, 'value' => 'null'), array('name' => 'args', 'type' => VariantMap, 'value' => 'null_array'))));
DefineFunction(array('name' => 'update', 'return' => array('type' => null), 'args' => array(array('name' => 'label', 'type' => Int64), array('name' => 'value', 'type' => Variant), array('name' => 'vars', 'type' => VariantMap))));
DefineFunction(array('name' => 'getVars', 'return' => array('type' => VariantMap)));
DefineProperty(array('name' => 'vars', 'type' => VariantMap, 'flags' => IsPrivate));
EndClass();
DefineFunction(array('name' => "getOffset", 'desc' => "Procedural style int timezone_offset_get ( DateTimeZone \$object , DateTime \$datetime ) This function returns the offset to GMT for the date/time specified in the datetime parameter. The GMT offset is calculated with the timezone information contained in the DateTimeZone object being used.", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns time zone offset in seconds on success or FALSE on failure."), 'args' => array(array('name' => "datetime", 'type' => Object, 'desc' => "DateTimeZone object returned by timezone_open()"))));
DefineFunction(array('name' => "getTransitions", 'desc' => "Procedural style array timezone_transitions_get ( DateTimeZone \$object [, int \$timestamp_begin [, int \$timestamp_end ]] )", 'flags' => HasDocComment, 'return' => array('type' => VariantMap, 'desc' => "Returns numerically indexed array containing associative array with all transitions on success or FALSE on failure.")));
DefineFunction(array('name' => "listAbbreviations", 'desc' => "Procedural style array timezone_abbreviations_list ( void )", 'flags' => IsStatic | HasDocComment, 'return' => array('type' => VariantMap, 'desc' => "Returns array on success or FALSE on failure.")));
DefineFunction(array('name' => "listIdentifiers", 'desc' => "Procedural style array timezone_identifiers_list ([ int \$what = DateTimeZone::ALL [, string \$country = NULL ]] )", 'flags' => IsStatic | HasDocComment, 'return' => array('type' => VariantMap, 'desc' => "Returns array on success or FALSE on failure.")));
EndClass();
BeginClass(array('name' => "DateInterval", 'desc' => "Represents a date interval.", 'flags' => HasDocComment, 'footer' => <<<EOT
public: static Object wrap(SmartObject<DateInterval> di) {
c_DateInterval *cdi = NEWOBJ(c_DateInterval)();
Object ret(cdi);
cdi->m_di = di;
return ret;
}
public: static SmartObject<DateInterval> unwrap(CObjRef dateinterval) {
SmartObject<c_DateInterval> cdi = dateinterval.getTyped<c_DateInterval>(true);
if (cdi.get() == NULL)
return SmartObject<DateInterval>();
return cdi->m_di;
}
private:
SmartObject<DateInterval> m_di;
public:
virtual ObjectData *clone();
EOT
));
# Object Psuedo-Properties - Implemented with __get()/__set()
# since underlying rel time must adjust automatically when set
#
# y - Number of years
# m - Number of months
// )
BeginClass(array('name' => 'GmagickPixel', 'bases' => array('Sweepable'), 'desc' => 'Gmagick pixel class', 'flags' => HasDocComment, 'footer' => <<<EOT
public:
PixelWand *get_PixelWand();
private:
PixelWand *pixel_wand;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "color", 'type' => String, 'value' => "null_string"))));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
BeginClass(array('name' => 'Gmagick', 'bases' => array('Sweepable'), 'desc' => 'Gmagick main class', 'flags' => HasDocComment, 'footer' => <<<EOT
private:
void checkResult(int result);
void checkNotEmpty();
void checkHasFormat();
void throwException(const char * magick_message, int magick_severity);
bool adjust_dimensions(bool bestfit, long desired_width, long desired_height, long *new_width, long *new_height);
MagickWand *magick_wand;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "destroy", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "getcopyright", 'flags' => HasDocComment, 'return' => array('type' => String)));
DefineFunction(array('name' => "readimageblob", 'flags' => HasDocComment, 'return' => array('type' => Object, 'desc' => "The Gmagick object itself (for method chaining)."), 'args' => array(array('name' => "blob", 'type' => String), array('name' => "filename", 'type' => String))));
DefineFunction(array('name' => "getimageblob", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "The image blob")));
DefineFunction(array('name' => "getimagefilename", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "The filename of a particular image in a sequence")));
DefineFunction(array('name' => "getimagetype", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "The potential image type")));
DefineFunction(array('name' => "getimageformat", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "The format of a particular image in a sequence")));
DefineFunction(array('name' => "getimagecolorspace", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "The color space of a particular image in a sequence")));
DefineFunction(array('name' => "getimageprofile", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "The named image profile"), 'args' => array(array('name' => "profile", 'type' => String))));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "DOMImplementation", 'desc' => "The DOMImplementation interface provides a number of methods for performing operations that are independent of any particular instance of the document object model.", 'flags' => HasDocComment));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "createDocument", 'desc' => "Creates a DOMDocument object of the specified type with its document element.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "A new DOMDocument object. If namespaceURI, qualifiedName, and doctype are null, the returned DOMDocument is empty with no document element"), 'args' => array(array('name' => "namespaceuri", 'type' => String, 'value' => "null_string", 'desc' => "The namespace URI of the document element to create."), array('name' => "qualifiedname", 'type' => String, 'value' => "null_string", 'desc' => "The qualified name of the document element to create."), array('name' => "doctypeobj", 'type' => Object, 'value' => "null_object", 'desc' => "The type of document to create or NULL."))));
DefineFunction(array('name' => "createDocumentType", 'desc' => "Creates an empty DOMDocumentType object. Entity declarations and notations are not made available. Entity reference expansions and default attribute additions do not occur.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "A new DOMDocumentType node with its ownerDocument set to NULL."), 'args' => array(array('name' => "qualifiedname", 'type' => String, 'value' => "null_string", 'desc' => "The qualified name of the document type to create."), array('name' => "publicid", 'type' => String, 'value' => "null_string", 'desc' => "The external subset public identifier."), array('name' => "systemid", 'type' => String, 'value' => "null_string", 'desc' => "The external subset system identifier."))));
DefineFunction(array('name' => "hasFeature", 'desc' => "Test if the DOM implementation implements a specific feature.\n\nYou can find a list of all features in the » Conformance section of the DOM specification.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "feature", 'type' => String, 'desc' => "The feature to test."), array('name' => "version", 'type' => String, 'desc' => "The version number of the feature to test. In level 2, this can be either 2.0 or 1.0."))));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "DOMXPath", 'bases' => array('Sweepable'), 'desc' => "Supports XPath 1.0", 'flags' => HasDocComment | NoDefaultSweep, 'footer' => <<<EOT
public:
xmlNodePtr m_node;
p_DOMDocument m_doc;
Array m_node_list;
int m_registerPhpFunctions;
Array m_registered_phpfunctions;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "doc", 'type' => Variant))));
DefineFunction(array('name' => "evaluate", 'desc' => "Executes the given XPath expression and returns a typed result if possible.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns a typed result if possible or a DOMNodeList containing all nodes matching the given XPath expression."), 'args' => array(array('name' => "expr", 'type' => String, 'desc' => "The XPath expression to execute."), array('name' => "context", 'type' => Object, 'value' => "null_object", 'desc' => "The optional contextnode can be specified for doing relative XPath queries. By default, the queries are relative to the root element."))));
DefineFunction(array('name' => "query", 'desc' => "Executes the given XPath expression.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns a DOMNodeList containing all nodes matching the given XPath expression. Any expression which do not return nodes will return an empty DOMNodeList."), 'args' => array(array('name' => "expr", 'type' => String, 'desc' => "The XPath expression to execute."), array('name' => "context", 'type' => Object, 'value' => "null_object", 'desc' => "The optional contextnode can be specified for doing relative XPath queries. By default, the queries are relative to the root element."))));
DefineFunction(array('name' => "registerNamespace", 'desc' => "Registers the namespaceURI and prefix with the DOMXPath object.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "prefix", 'type' => String, 'desc' => "The prefix."), array('name' => "uri", 'type' => String, 'desc' => "The URI of the namespace."))));
DefineFunction(array('name' => "registerPHPFunctions", 'desc' => "This method enables the ability to use PHP functions within XPath expressions.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "No value is returned."), 'args' => array(array('name' => "funcs", 'type' => Variant, 'value' => "null", 'desc' => "Use this parameter to only allow certain functions to be called from XPath.\n\nThis parameter can be either a string (a function name) or an array of function names."))));
DefineFunction(array('name' => "__get", 'flags' => HasDocComment, 'return' => array('type' => Variant), 'args' => array(array('name' => "name", 'type' => Variant))));
DefineFunction(array('name' => "__set", 'flags' => HasDocComment, 'return' => array('type' => Variant), 'args' => array(array('name' => "name", 'type' => Variant), array('name' => "value", 'type' => Variant))));
DefineFunction(array('name' => "__isset", 'flags' => HasDocComment, 'return' => array('type' => Boolean), 'args' => array(array('name' => "name", 'type' => Variant))));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
'type' => Variant,
),
));
EndClass(
);
///////////////////////////////////////////////////////////////////////////////
BeginClass(
array(
'name' => "DateTimeZone",
'desc' => "Representation of time zone.",
'flags' => HasDocComment,
'footer' => <<<EOT
private:
SmartObject<TimeZone> m_tz;
public:
virtual ObjectData *clone();
EOT
,
));
DefineConstant(
array(
'name' => "AFRICA",
'type' => Int64,
));
DefineConstant(
array(
DefineFunction(array('name' => "getCommand", 'desc' => "Debugger command end user typed.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => String, 'desc' => "The command text.")));
DefineFunction(array('name' => "arg", 'desc' => "Tests if an argument matches a pre-defined keyword. As long as it matches the keyword partially and case-insensitively, it is considered as a match. For example, \$client->arg(2, 'foo') will return TRUE if user inputs 'f' or 'fo' or 'Fo' for the 2nd argument.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => Boolean, 'desc' => "TRUE if matched. FALSE otherwise."), 'args' => array(array('name' => "index", 'type' => Int32, 'desc' => "Argument index."), array('name' => "str", 'type' => String, 'desc' => "The string to compare with."))));
DefineFunction(array('name' => "argCount", 'desc' => "Count of total arguments.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => Int64, 'desc' => "The count, not including user command itself.")));
DefineFunction(array('name' => "argValue", 'desc' => "Gets value of an argument.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => String, 'desc' => "String value of an argument."), 'args' => array(array('name' => "index", 'type' => Int32, 'desc' => "Argument index."))));
DefineFunction(array('name' => "argRest", 'desc' => "Gets remaining arguments all together as a single string.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => String, 'desc' => "The string that has all argument at and after certain index."), 'args' => array(array('name' => "index", 'type' => Int32, 'desc' => "The starting index to include arguments."))));
DefineFunction(array('name' => "args", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => StringVec)));
DefineFunction(array('name' => "send", 'desc' => "Sends a debugger command to debugger proxy.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => Variant, 'desc' => "TRUE if successful, FALSE otherwise."), 'args' => array(array('name' => "cmd", 'type' => Object, 'desc' => "The command to send."))));
DefineFunction(array('name' => "xend", 'desc' => "Exchanges command with proxy: sends a command to debugger and expects and receives a command from debugger.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => Variant, 'desc' => "The received command, and it is always the same type as what it sends, so the same command class can handle processing at both sending and receiving sides."), 'args' => array(array('name' => "cmd", 'type' => Object, 'desc' => "The command to send."))));
DefineFunction(array('name' => "getCurrentLocation", 'desc' => "Gets current source location.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => Variant, 'desc' => "An array in a format of array('file' => {source file name}, 'line' => {line number}, 'namespace' => {namespace code is in}, 'class' => {class code is in}, 'function' => {function code is in}, 'text' => {human readable description of current source location}).")));
DefineFunction(array('name' => "getStackTrace", 'desc' => "Gets current stacktrace.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => Variant, 'desc' => "An array of stacktrace frames.")));
DefineFunction(array('name' => "getFrame", 'desc' => "Returns current frame index.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => Int64, 'desc' => "An index indicating which frame end user has moved to for inspection.")));
DefineFunction(array('name' => "printFrame", 'desc' => "Prints a stacktrace frame.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => null), 'args' => array(array('name' => "index", 'type' => Int32, 'desc' => "Which frame to print."))));
DefineFunction(array('name' => "addCompletion", 'desc' => "Adds string(s) to auto-completion. This function is only effective inside DebuggerClientCmdUser::onAutoComplete().", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => null), 'args' => array(array('name' => "list", 'type' => Variant, 'desc' => "A single string, an AUTO_COMPLETE_ constant or an array of strings."))));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "DebuggerClient", 'desc' => "", 'bases' => array('Sweepable'), 'flags' => HasDocComment | HipHopSpecific | NoDefaultSweep, 'footer' => <<<EOT
public:
Eval::DebuggerClient *m_client;
EOT
));
DefineConstant(array('name' => "STATE_INVALID", 'type' => Int64));
DefineConstant(array('name' => "STATE_UNINIT", 'type' => Int64));
DefineConstant(array('name' => "STATE_INITIALIZING", 'type' => Int64));
DefineConstant(array('name' => "STATE_READY_FOR_COMMAND", 'type' => Int64));
DefineConstant(array('name' => "STATE_BUSY", 'type' => Int64));
DefineFunction(array('name' => "__construct", 'desc' => "Constructor", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => null)));
DefineFunction(array('name' => "getState", 'desc' => "get current state of the debugger client", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => Int64, 'desc' => "One of the constants")));
DefineFunction(array('name' => "init", 'desc' => "initialize the debugger client", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => Variant, 'desc' => "TBD"), 'args' => array(array('name' => "options", 'type' => Variant, 'desc' => "array for passing options"))));
DefineFunction(array('name' => "processCmd", 'desc' => "issue a command to debugger client", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => Variant, 'desc' => "TBD"), 'args' => array(array('name' => "cmdName", 'type' => Variant, 'desc' => "name of the command to be executed"), array('name' => "args", 'type' => Variant, 'desc' => "A vector array of strings to be used as arguments"))));
EndClass();
//
// array (
// 'name' => name of the property
// 'type' => type of the property
// 'flags' => attributes of the property
// 'desc' => description of the property
// 'note' => additional note about this property's schema
// )
//
// EndClass()
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "XMLWriter", 'bases' => array('Sweepable'), 'desc' => "", 'flags' => HasDocComment, 'footer' => <<<EOT
public:
SmartObject<File> m_uri;
private:
xmlTextWriterPtr m_ptr;
xmlBufferPtr m_output;
xmlOutputBufferPtr m_uri_output;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "openMemory", 'flags' => HasDocComment, 'return' => array('type' => Boolean)));
DefineFunction(array('name' => "openURI", 'flags' => HasDocComment, 'return' => array('type' => Boolean), 'args' => array(array('name' => "uri", 'type' => String))));
DefineFunction(array('name' => "setIndentString", 'flags' => HasDocComment, 'return' => array('type' => Boolean), 'args' => array(array('name' => "indentstring", 'type' => String))));
DefineFunction(array('name' => "setIndent", 'flags' => HasDocComment, 'return' => array('type' => Boolean), 'args' => array(array('name' => "indent", 'type' => Boolean))));
DefineFunction(array('name' => "startDocument", 'flags' => HasDocComment, 'return' => array('type' => Boolean), 'args' => array(array('name' => "version", 'type' => String, 'value' => "\"1.0\""), array('name' => "encoding", 'type' => String, 'value' => "null_string"), array('name' => "standalone", 'type' => String, 'value' => "null_string"))));
DefineFunction(array('name' => "startElement", 'flags' => HasDocComment, 'return' => array('type' => Boolean), 'args' => array(array('name' => "name", 'type' => String))));
DefineFunction(array('name' => "startElementNS", 'flags' => HasDocComment, 'return' => array('type' => Boolean), 'args' => array(array('name' => "prefix", 'type' => String), array('name' => "name", 'type' => String), array('name' => "uri", 'type' => String))));
DefineFunction(array('name' => "writeElementNS", 'flags' => HasDocComment, 'return' => array('type' => Boolean), 'args' => array(array('name' => "prefix", 'type' => String), array('name' => "name", 'type' => String), array('name' => "uri", 'type' => String), array('name' => "content", 'type' => String, 'value' => "null_string"))));
DefineFunction(array('name' => "writeElement", 'flags' => HasDocComment, 'return' => array('type' => Boolean), 'args' => array(array('name' => "name", 'type' => String), array('name' => "content", 'type' => String, 'value' => "null_string"))));
DefineFunction(array('name' => "endElement", 'flags' => HasDocComment, 'return' => array('type' => Boolean)));
// DefineProperty
// DefineProperty
//
// array (
// 'name' => name of the property
// 'type' => type of the property
// 'flags' => attributes of the property
// 'desc' => description of the property
// 'note' => additional note about this property's schema
// )
//
// EndClass()
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "SpoofChecker", 'desc' => "Unicode Security and Spoofing Detection (see http://icu-project.org/apiref/icu4c/uspoof_8h.html for details)", 'flags' => HasDocComment, 'footer' => <<<EOT
private: USpoofChecker *m_spoof_checker;
EOT
));
DefineConstant(array('name' => "SINGLE_SCRIPT_CONFUSABLE", 'type' => Int64));
DefineConstant(array('name' => "MIXED_SCRIPT_CONFUSABLE", 'type' => Int64));
DefineConstant(array('name' => "WHOLE_SCRIPT_CONFUSABLE", 'type' => Int64));
DefineConstant(array('name' => "ANY_CASE", 'type' => Int64));
DefineConstant(array('name' => "SINGLE_SCRIPT", 'type' => Int64));
DefineConstant(array('name' => "INVISIBLE", 'type' => Int64));
DefineConstant(array('name' => "CHAR_LIMIT", 'type' => Int64));
DefineFunction(array('name' => "__construct", 'desc' => "Creates a spoof checker that checks for visually confusing characters in a string. By default, runs the following tests: SINGLE_SCRIPT_CONFUSABLE, MIXED_SCRIPT_CONFUSABLE, WHOLE_SCRIPT_CONFUSABLE, ANY_CASE, INVISIBLE.", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "isSuspicious", 'desc' => "Check the specified UTF-8 string for possible security or spoofing issues.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE if the string has possible security or spoofing issues, FALSE otherwise."), 'args' => array(array('name' => "text", 'type' => String, 'desc' => "A UTF-8 string to be checked for possible security issues."), array('name' => "issuesFound", 'type' => Variant | Reference, 'value' => "null", 'desc' => "If passed, this will hold an integer value with bits set for any potential security or spoofing issues detected. Zero is returned if no issues are found with the input string."))));
DefineFunction(array('name' => "areConfusable", 'desc' => "Check the whether two specified UTF-8 strings are visually confusable. The types of confusability to be tested - single script, mixed script, or whole script - are determined by the check options set for this instance.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE if the two strings are confusable, FALSE otherwise."), 'args' => array(array('name' => "s1", 'type' => String, 'desc' => "The first of the two UTF-8 strings to be compared for confusability."), array('name' => "s2", 'type' => String, 'desc' => "The second of the two UTF-8 strings to be compared for confusability."), array('name' => "issuesFound", 'type' => Variant | Reference, 'value' => "null", 'desc' => "If passed, this will hold an integer value with bit(s) set corresponding to the type of confusability found, as defined by the constant values stored in this class. Zero is returned if the strings are not confusable."))));
DefineFunction(array('name' => "setAllowedLocales", 'desc' => "Limit characters that are acceptable in identifiers being checked to those normally used with the languages associated with the specified locales.", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "localesList", 'type' => String, 'desc' => "A list of locales, from which the language and associated script are extracted. The locales are comma-separated if there is more than one. White space may not appear within an individual locale, but is ignored otherwise. The locales are syntactically like those from the HTTP Accept-Language header. If the localesList is empty, no restrictions will be placed on the allowed characters."))));
DefineFunction(array('name' => "setChecks", 'desc' => "Specify the set of checks that will be performed by the check function", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "checks", 'type' => Int32, 'desc' => "The set of checks that this spoof checker will perform. The value is a bit set, obtained by OR-ing together the constant values in this class."))));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "DebuggerProxy", 'desc' => "", 'footer' => <<<EOT
public:
Eval::DebuggerProxy *m_proxy;
EOT
));
DefineFunction(array('name' => "__construct", 'return' => array('type' => null)));
DefineFunction(array('name' => "islocal", 'return' => array('type' => Boolean)));
DefineFunction(array('name' => "send", 'return' => array('type' => Variant), 'args' => array(array('name' => "cmd", 'type' => 'DebuggerCommand'))));
DefineFunction(array('name' => "__destruct", 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "DebuggerClient", 'desc' => "", 'footer' => <<<EOT
public:
Eval::DebuggerClient *m_client;
EOT
));
DefineConstant(array('name' => "AUTO_COMPLETE_FILENAMES", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_VARIABLES", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_CONSTANTS", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_CLASSES", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_FUNCTIONS", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_CLASS_METHODS", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_CLASS_PROPERTIES", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_CLASS_CONSTANTS", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_KEYWORDS", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_CODE", 'type' => Int64));
DefineFunction(array('name' => "__construct", 'return' => array('type' => null)));
DefineFunction(array('name' => "quit", 'return' => array('type' => null)));
DefineFunction(array('name' => "print", 'flags' => VariableArguments, 'return' => array('type' => null), 'args' => array(array('name' => "format", 'type' => String))));
DefineConstant(array('name' => "W3C", 'type' => String));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "time", 'type' => String, 'value' => "\"now\""), array('name' => "timezone", 'type' => Object, 'value' => "null_object"))));
DefineFunction(array('name' => "format", 'desc' => "Procedural style string date_format ( DateTime \$object , string \$format ) Returns date formatted according to given format.", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "Returns the formatted date string on success or FALSE on failure."), 'args' => array(array('name' => "format", 'type' => String, 'desc' => "DateTime object returned by date_create()"))));
DefineFunction(array('name' => "getoffset", 'desc' => "Procedural style int date_offset_get ( DateTime \$object ) Returns the timezone offset.", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns the timezone offset in seconds from UTC on success or FALSE on failure.")));
DefineFunction(array('name' => "gettimezone", 'desc' => "Procedural style DateTimeZone date_timezone_get ( DateTime \$object ) Return time zone relative to given DateTime.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns a DateTimeZone object on success or FALSE on failure.")));
DefineFunction(array('name' => "modify", 'desc' => "Procedural style DateTime date_modify ( DateTime \$object , string \$modify ) Alter the timestamp of a DateTime object by incrementing or decrementing in a format accepted by strtotime().", 'flags' => HasDocComment, 'return' => array('type' => Object, 'desc' => "Returns the modified DateTime object or FALSE on failure."), 'args' => array(array('name' => "modify", 'type' => String, 'desc' => "DateTime object returned by date_create(). The function modifies this object."))));
DefineFunction(array('name' => "setdate", 'desc' => "Procedural style DateTime date_date_set ( DateTime \$object , int \$year , int \$month , int \$day ) Resets the current date of the DateTime object to a different date.", 'flags' => HasDocComment, 'return' => array('type' => Object, 'desc' => "Returns the modified DateTime object or FALSE on failure."), 'args' => array(array('name' => "year", 'type' => Int64, 'desc' => "DateTime object returned by date_create(). The function modifies this object."), array('name' => "month", 'type' => Int64, 'desc' => "Year of the date."), array('name' => "day", 'type' => Int64, 'desc' => "Month of the date."))));
DefineFunction(array('name' => "setisodate", 'desc' => "Procedural style DateTime date_isodate_set ( DateTime \$object , int \$year , int \$week [, int \$day = 1 ] ) Set a date according to the ISO 8601 standard - using weeks and day offsets rather than specific dates.", 'flags' => HasDocComment, 'return' => array('type' => Object, 'desc' => "Returns the modified DateTime object or FALSE on failure."), 'args' => array(array('name' => "year", 'type' => Int64, 'desc' => "DateTime object returned by date_create(). The function modifies this object."), array('name' => "week", 'type' => Int64, 'desc' => "Year of the date."), array('name' => "day", 'type' => Int64, 'value' => "1", 'desc' => "Week of the date."))));
DefineFunction(array('name' => "settime", 'desc' => "Procedural style DateTime date_time_set ( DateTime \$object , int \$hour , int \$minute [, int \$second = 0 ] ) Resets the current time of the DateTime object to a different time.", 'flags' => HasDocComment, 'return' => array('type' => Object, 'desc' => "Returns the modified DateTime object or FALSE on failure."), 'args' => array(array('name' => "hour", 'type' => Int64, 'desc' => "DateTime object returned by date_create(). The function modifies this object."), array('name' => "minute", 'type' => Int64, 'desc' => "Hour of the time."), array('name' => "second", 'type' => Int64, 'value' => "0", 'desc' => "Minute of the time."))));
DefineFunction(array('name' => "settimezone", 'desc' => "Procedural style DateTime date_timezone_set ( DateTime \$object , DateTimeZone \$timezone )", 'flags' => HasDocComment, 'return' => array('type' => Object, 'desc' => "Returns the modified DateTime object or FALSE on failure."), 'args' => array(array('name' => "timezone", 'type' => Object, 'desc' => "DateTime object returned by date_create(). The function modifies this object."))));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "DateTimeZone", 'desc' => "Representation of time zone.", 'flags' => HasDocComment, 'footer' => <<<EOT
private:
SmartObject<TimeZone> m_tz;
EOT
));
DefineConstant(array('name' => "AFRICA", 'type' => Int64));
DefineConstant(array('name' => "AMERICA", 'type' => Int64));
DefineConstant(array('name' => "ANTARCTICA", 'type' => Int64));
DefineConstant(array('name' => "ARCTIC", 'type' => Int64));
DefineConstant(array('name' => "ASIA", 'type' => Int64));
DefineConstant(array('name' => "ATLANTIC", 'type' => Int64));
DefineConstant(array('name' => "AUSTRALIA", 'type' => Int64));
DefineConstant(array('name' => "EUROPE", 'type' => Int64));
DefineConstant(array('name' => "INDIAN", 'type' => Int64));
DefineConstant(array('name' => "PACIFIC", 'type' => Int64));
DefineConstant(array('name' => "UTC", 'type' => Int64));
DefineConstant(array('name' => "ALL", 'type' => Int64));
DefineConstant(array('name' => "ALL_WITH_BC", 'type' => Int64));
DefineFunction(array('name' => "getlocale", 'desc' => "Procedural style string collator_get_locale ( Collator \$coll , int \$type ) Get collector locale name.", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "Real locale name from which the collation data comes. If the collator was instantiated from rules or an error occurred, returns boolean FALSE."), 'args' => array(array('name' => "type", 'type' => Int64, 'value' => "0", 'desc' => "Collator object."))));
DefineFunction(array('name' => "getstrength", 'desc' => "Procedural style int collator_get_strength ( Collator \$coll )", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns current collation strength, or boolean FALSE on error.")));
DefineFunction(array('name' => "setattribute", 'desc' => "Procedural style bool collator_set_attribute ( Collator \$coll , int \$attr , int \$val )", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "attr", 'type' => Int64, 'desc' => "Collator object."), array('name' => "val", 'type' => Int64))));
DefineFunction(array('name' => "setstrength", 'desc' => "Procedural style bool collator_set_strength ( Collator \$coll , int \$strength ) The » ICU Collation Service supports many levels of comparison (named \"Levels\", but also known as \"Strengths\"). Having these categories enables ICU to sort strings precisely according to local conventions. However, by allowing the levels to be selectively employed, searching for a string in text can be performed with various matching conditions.\n\n\n\nPrimary Level: Typically, this is used to denote differences between base characters (for example, \"a\" < \"b\"). It is the strongest difference. For example, dictionaries are divided into different sections by base character. This is also called the level1 strength.\n\nSecondary Level: Accents in the characters are considered secondary differences (for example, \"as\" < \"à s\" < \"at\"). Other differences between letters can also be considered secondary differences, depending on the language. A secondary difference is ignored when there is a primary difference anywhere in the strings. This is also called the level2 strength.\n\nNote: In some languages (such as Danish), certain accented letters are considered to be separate base characters. In most languages, however, an accented letter only has a secondary difference from the unaccented version of that letter.\n\nTertiary Level: Upper and lower case differences in characters are distinguished at the tertiary level (for example, \"ao\" < \"Ao\" < \"aò\"). In addition, a variant of a letter differs from the base form on the tertiary level (such as \"A\" and \" \"). Another example is the difference between large and small Kana. A tertiary difference is ignored when there is a primary or secondary difference anywhere in the strings. This is also called the level3 strength.\n\nQuaternary Level: When punctuation is ignored (see Ignoring Punctuations ) at level 13, an additional level can be used to distinguish words with and without punctuation (for example, \"ab\" < \"a-b\" < \"aB\"). This difference is ignored when there is a primary, secondary or tertiary difference. This is also known as the level4 strength. The quaternary level should only be used if ignoring punctuation is required or when processing Japanese text (see Hiragana processing).\n\nIdentical Level: When all other levels are equal, the identical level is used as a tiebreaker. The Unicode code point values of the NFD form of each string are compared at this level, just in case there is no difference at levels 14. For example, Hebrew cantillation marks are only distinguished at this level. This level should be used sparingly, as only code point values differences between two strings is an extremely rare occurrence. Using this level substantially decreases the performance for both incremental comparison and sort key generation (as well as increasing the sort key length). It is also known as level 5 strength.\n\nFor example, people may choose to ignore accents or ignore accents and case when searching for text. Almost all characters are distinguished by the first three levels, and in most locales the default value is thus Tertiary. However, if Alternate is set to be Shifted, then the Quaternary strength can be used to break ties among whitespace, punctuation, and symbols that would otherwise be ignored. If very fine distinctions among characters are required, then the Identical strength can be used (for example, Identical Strength distinguishes between the Mathematical Bold Small A and the Mathematical Italic Small A.). However, using levels higher than Tertiary the Identical strength result in significantly longer sort keys, and slower string comparison performance for equal strings.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "strength", 'type' => Int64, 'desc' => "Collator object."))));
DefineFunction(array('name' => "sortwithsortkeys", 'desc' => "Procedural style bool collator_sort_with_sort_keys ( Collator \$coll , array &\$arr ) Similar to collator_sort() but uses ICU sorting keys produced by ucol_getSortKey() to gain more speed on large arrays.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "arr", 'type' => Variant | Reference, 'desc' => "Collator object."))));
DefineFunction(array('name' => "sort", 'desc' => "Procedural style bool collator_sort ( Collator \$coll , array &\$arr [, int \$sort_flag ] ) This function sorts an array according to current locale rules.\n\nEquivalent to standard PHP sort() .", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "arr", 'type' => Variant | Reference, 'desc' => "Collator object."), array('name' => "sort_flag", 'type' => Int64, 'value' => "q_Collator\${$SORT_REGULAR}", 'desc' => "Array of strings to sort."))));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "Locale", 'desc' => "A \"Locale\" is an identifier used to get language, culture, or regionally-specific behavior from an API. PHP locales are organized and identified the same way that the CLDR locales used by ICU (and many vendors of Unix-like operating systems, the Mac, Java, and so forth) use. Locales are identified using RFC 4646 language tags (which use hyphen, not underscore) in addition to the more traditional underscore-using identifiers. Unless otherwise noted the functions in this class are tolerant of both formats.\n\nExamples of identifiers include: en-US (English, United States) zh-Hant-TW (Chinese, Traditional Script, Taiwan) fr-CA, fr-FR (French for Canada and France respectively) The Locale class (and related procedural functions) are used to interact with locale identifiers--to verify that an ID is well-formed, valid, etc. The extensions used by CLDR in UAX #35 (and inherited by ICU) are valid and used wherever they would be in ICU normally. Locales cannot be instantiated as objects. All of the functions/methods provided are static. The null or empty string obtains the \"root\" locale. The \"root\" locale is equivalent to \"en_US_POSIX\" in CLDR. Language tags (and thus locale identifiers) are case insensitive. There exists a canonicalization function to make case match the specification.", 'flags' => HasDocComment));
DefineConstant(array('name' => "ACTUAL_LOCALE", 'type' => Int64));
DefineConstant(array('name' => "VALID_LOCALE", 'type' => Int64));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "Normalizer", 'bases' => array('Sweepable'), 'desc' => "Normalization is a process that involves transforming characters and sequences of characters into a formally-defined underlying representation. This process is most important when text needs to be compared for sorting and searching, but it is also used when storing text to ensure that the text is stored in a consistent representation.\n\nThe Unicode Consortium has defined a number of normalization forms reflecting the various needs of applications: Normalization Form D (NFD) - Canonical Decomposition Normalization Form C (NFC) - Canonical Decomposition followed by Canonical Composition Normalization Form KD (NFKD) - Compatibility Decomposition Normalization Form KC (NFKC) - Compatibility Decomposition followed by Canonical Composition The different forms are defined in terms of a set of transformations on the text, transformations that are expressed by both an algorithm and a set of data files.", 'flags' => HasDocComment));
DefineConstant(array('name' => "NONE", 'type' => Int64));
DefineConstant(array('name' => "FORM_D", 'type' => Int64));
DefineConstant(array('name' => "NFD", 'type' => Int64));
DefineConstant(array('name' => "FORM_KD", 'type' => Int64));
DefineConstant(array('name' => "NFKD", 'type' => Int64));
DefineConstant(array('name' => "FORM_C", 'type' => Int64));
DefineConstant(array('name' => "NFC", 'type' => Int64));
DefineConstant(array('name' => "FORM_KC", 'type' => Int64));
DefineConstant(array('name' => "NFKC", 'type' => Int64));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "isnormalized", 'desc' => "Procedural style bool normalizer_is_normalized ( string \$input [, string \$form = Normalizer::FORM_C ] ) Checks if the provided string is already in the specified normalization form.", 'flags' => IsStatic | HasDocComment, 'return' => array('type' => Variant, 'desc' => "TRUE if normalized, FALSE otherwise or if there an error"), 'args' => array(array('name' => "input", 'type' => String), array('name' => "form", 'type' => Int64, 'value' => "q_Normalizer\${$FORM_C}", 'desc' => "One of the normalization forms."))));
DefineFunction(array('name' => "normalize", 'desc' => "Procedural style string normalizer_normalize ( string \$input [, string \$form = Normalizer::FORM_C ] ) Normalizes the input provided and returns the normalized string", 'flags' => IsStatic | HasDocComment, 'return' => array('type' => Variant, 'desc' => "NULL if an error occurred."), 'args' => array(array('name' => "input", 'type' => String), array('name' => "form", 'type' => Int64, 'value' => "q_Normalizer\${$FORM_C}"))));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
DefineFunction(array('name' => "clear", 'flags' => HasDocComment, 'desc' => "Removes all key/value pairs from the StableMap.", 'return' => array('type' => Object)));
DefineFunction(array('name' => "contains", 'flags' => HasDocComment, 'desc' => "Returns true if the specified key is present in the " . "StableMap, false otherwise.", 'return' => array('type' => Boolean), 'args' => array(array('name' => "key", 'type' => Variant))));
DefineFunction(array('name' => "remove", 'flags' => HasDocComment, 'desc' => "Removes the specified key from this StableMap.", 'return' => array('type' => Object), 'args' => array(array('name' => "key", 'type' => Variant))));
// This method is deprecated and will be removed soon
DefineFunction(array('name' => "discard", 'flags' => HasDocComment, 'desc' => "Removes the specified key from this StableMap.", 'return' => array('type' => Object), 'args' => array(array('name' => "key", 'type' => Variant))));
DefineFunction(array('name' => "toArray", 'flags' => HasDocComment, 'desc' => "Returns an array containing the key/value pairs from this " . "StableMap.", 'return' => array('type' => VariantMap)));
// This method is deprecated and will be removed soon
DefineFunction(array('name' => "copyAsArray", 'flags' => HasDocComment, 'desc' => "Returns an array containing the key/value pairs from this " . "StableMap.", 'return' => array('type' => VariantMap)));
DefineFunction(array('name' => "toKeysArray", 'flags' => HasDocComment, 'desc' => "Returns an array containing the keys from this " . "StableMap.", 'return' => array('type' => VariantMap)));
DefineFunction(array('name' => "values", 'flags' => HasDocComment, 'desc' => "Returns a Vector containing the values from this " . "StableMap.", 'return' => array('type' => Object)));
DefineFunction(array('name' => "toValuesArray", 'flags' => HasDocComment, 'desc' => "Returns an array containing the values from this " . "StableMap.", 'return' => array('type' => VariantMap)));
DefineFunction(array('name' => "updateFromArray", 'flags' => HasDocComment, 'desc' => "Inserts the key/value pairs from the specified array into " . "this StableMap.", 'return' => array('type' => Object), 'args' => array(array('name' => "arr", 'type' => Variant))));
DefineFunction(array('name' => "updateFromIterable", 'flags' => HasDocComment, 'desc' => "Inserts the key/value pairs produced by the specified " . "Iterable.", 'return' => array('type' => Object), 'args' => array(array('name' => "it", 'type' => Variant))));
DefineFunction(array('name' => "differenceByKey", 'flags' => HasDocComment, 'return' => array('type' => Object), 'args' => array(array('name' => "it", 'type' => Variant))));
DefineFunction(array('name' => "getIterator", 'flags' => HasDocComment, 'desc' => "Returns an iterator that points to beginning of this " . "StableMap.", 'return' => array('type' => Object)));
DefineFunction(array('name' => "__get", 'flags' => HasDocComment, 'return' => array('type' => Variant), 'args' => array(array('name' => "name", 'type' => Variant))));
DefineFunction(array('name' => "__set", 'flags' => HasDocComment, 'return' => array('type' => Variant), 'args' => array(array('name' => "name", 'type' => Variant), array('name' => "value", 'type' => Variant))));
DefineFunction(array('name' => "__isset", 'flags' => HasDocComment, 'return' => array('type' => Boolean), 'args' => array(array('name' => "name", 'type' => Variant))));
DefineFunction(array('name' => "__unset", 'flags' => HasDocComment, 'return' => array('type' => Variant), 'args' => array(array('name' => "name", 'type' => Variant))));
DefineFunction(array('name' => "__toString", 'return' => array('type' => String)));
DefineFunction(array('name' => "fromArray", 'flags' => IsStatic | HasDocComment, 'desc' => "Returns a StableMap containing the key/value pairs from the " . "specified array.", 'return' => array('type' => Object), 'args' => array(array('name' => "mp", 'type' => Variant))));
DefineFunction(array('name' => "fromIterable", 'flags' => IsStatic | HasDocComment, 'desc' => "Returns a StableMap containing the key/value pairs produced " . "by the specified Iterable.", 'return' => array('type' => Object), 'args' => array(array('name' => "mp", 'type' => Variant))));
EndClass();
BeginClass(array('name' => "StableMapIterator", 'ifaces' => array('Iterator'), 'desc' => "An iterator implementation for iterating over a StableMap.", 'flags' => IsFinal | HasDocComment));
DefineFunction(array('name' => "__construct", 'return' => array('type' => null)));
DefineFunction(array('name' => "current", 'desc' => "Returns the current value that the iterator points to.", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "key", 'desc' => "Returns the current key that the iterator points to.", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "valid", 'desc' => "Returns true if the iterator points to a valid value, " . "returns false otherwise.", 'flags' => HasDocComment, 'return' => array('type' => Boolean)));
DefineFunction(array('name' => "next", 'desc' => "Advance this iterator forward one position.", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "rewind", 'desc' => "Move this iterator back to the first position.", 'flags' => HasDocComment, 'return' => array('type' => null)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "DebuggerProxy", 'desc' => "", 'flags' => HasDocComment | HipHopSpecific, 'footer' => <<<EOT
public:
Eval::DebuggerProxy *m_proxy;
EOT
));
DefineFunction(array('name' => "__construct", 'desc' => "Constructor of DebuggerProxy.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => null)));
DefineFunction(array('name' => "isLocal", 'desc' => "Whether this proxy is running locally for debugging a local script, or running remotely on a server.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => Boolean, 'desc' => "TRUE if locally, FALSE if remote.")));
DefineFunction(array('name' => "send", 'desc' => "Sends a command back to DebuggerClient.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => Variant, 'desc' => "TRUE if successful, FALSE otherwise."), 'args' => array(array('name' => "cmd", 'type' => 'DebuggerCommand', 'desc' => "The command to send to client."))));
DefineFunction(array('name' => "__destruct", 'desc' => "Destructor of DebuggerProxy.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => Variant, 'desc' => "Always returns null.")));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "DebuggerClient", 'desc' => "", 'flags' => HasDocComment | HipHopSpecific, 'footer' => <<<EOT
public:
Eval::DebuggerClient *m_client;
EOT
));
DefineConstant(array('name' => "AUTO_COMPLETE_FILENAMES", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_VARIABLES", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_CONSTANTS", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_CLASSES", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_FUNCTIONS", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_CLASS_METHODS", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_CLASS_PROPERTIES", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_CLASS_CONSTANTS", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_KEYWORDS", 'type' => Int64));
DefineConstant(array('name' => "AUTO_COMPLETE_CODE", 'type' => Int64));
DefineFunction(array('name' => "__construct", 'desc' => "Constructor of DebuggerClient.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => null)));
DefineFunction(array('name' => "quit", 'desc' => "Quits the client.", 'flags' => HasDocComment | HipHopSpecific, 'return' => array('type' => null)));
DefineFunction(array('name' => "print", 'desc' => "Prints some text without any color.", 'flags' => HasDocComment | HipHopSpecific | VariableArguments, 'return' => array('type' => null), 'args' => array(array('name' => "format", 'type' => String, 'desc' => "Format string in printf() style."))));
DefineFunction(array('name' => "exec", 'desc' => "PDO::exec() executes an SQL statement in a single function call, returning the number of rows affected by the statement.\n\nPDO::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().", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "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 0. WarningThis function may return Boolean FALSE, but may also return a non-Boolean value which evaluates to FALSE, such as 0 or \"\". Please read the section on Booleans for more information. Use the === operator for testing the return value of this function.\n\nThe following example incorrectly relies on the return value of PDO::exec(), wherein a statement that affected 0 rows results in a call to die():"), 'args' => array(array('name' => "query", 'type' => String, 'desc' => "The SQL statement to prepare and execute.\n\nData inside the query should be properly escaped."))));
DefineFunction(array('name' => "lastinsertid", 'desc' => "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() requires you to specify the name of a sequence object for the name parameter.\n\nThis 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.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "If a sequence name was not specified for the name parameter, PDO::lastInsertId() returns a string representing the row ID of the last row that was inserted into the database.\n\nIf a sequence name was specified for the name parameter, PDO::lastInsertId() returns a string representing the last value retrieved from the specified sequence object.\n\nIf the PDO driver does not support this capability, PDO::lastInsertId() triggers an IM001 SQLSTATE."), 'args' => array(array('name' => "seqname", 'type' => String, 'value' => "null_string", 'desc' => "Name of the sequence object from which the ID should be returned."))));
DefineFunction(array('name' => "errorcode", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "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.\n\nPDO::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.\n\nReturns NULL if no operation has been run on the database handle.")));
DefineFunction(array('name' => "errorinfo", 'flags' => HasDocComment, 'return' => array('type' => VariantVec, 'desc' => "PDO::errorInfo() returns an array of error information about the last operation performed by this database handle. The array consists of the following fields: Element Information 0 SQLSTATE error code (a five characters alphanumeric identifier defined in the ANSI SQL standard). 1 Driver-specific error code. 2 Driver-specific error message.\n\nIf the SQLSTATE error code is not set or there is no driver-specific error, the elements following element 0 will be set to NULL.\n\nPDO::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.")));
DefineFunction(array('name' => "query", 'desc' => "PDO::query() executes an SQL statement in a single function call, returning the result set (if any) returned by the statement as a PDOStatement object.\n\nFor a query that you need to issue multiple times, you will realize better performance if you prepare a PDOStatement object using PDO::prepare() and issue the statement with multiple calls to PDOStatement::execute().\n\nIf 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 PDOStatement object before issuing your next call to PDO::query().\n\nAlthough this function is only documented as having a single parameter, you may pass additional arguments to this function. They will be treated as though you called PDOStatement::setFetchMode() on the resultant statement object.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "PDO::query() returns a PDOStatement object, or FALSE on failure."), 'args' => array(array('name' => "sql", 'type' => String, 'desc' => "The SQL statement to prepare and execute.\n\nData inside the query should be properly escaped."))));
DefineFunction(array('name' => "quote", 'desc' => "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.\n\nIf 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.\n\nNot all PDO drivers implement this method (notably PDO_ODBC). Consider using prepared statements instead.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns a quoted string that is theoretically safe to pass into an SQL statement. Returns FALSE if the driver does not support quoting in this way."), 'args' => array(array('name' => "str", 'type' => String, 'desc' => "The string to be quoted."), array('name' => "paramtype", 'type' => Int64, 'value' => "q_PDO\${$PARAM_STR}", 'desc' => "Provides a data type hint for drivers that have alternate quoting styles."))));
DefineFunction(array('name' => "__wakeup", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "__sleep", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "getavailabledrivers", 'desc' => "This function returns all currently available PDO drivers which can be used in DSN parameter of PDO::__construct(). This is a static method.", 'flags' => IsStatic | HasDocComment, 'return' => array('type' => StringVec, 'desc' => "PDO::getAvailableDrivers() returns an array of PDO driver names. If no drivers are available, it returns an empty array.")));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "PDOStatement", 'ifaces' => array('Iterator'), 'bases' => array('Sweepable'), 'desc' => "Represents a prepared statement and, after the statement is executed, an associated result set.", 'flags' => HasDocComment, 'footer' => <<<EOT
public: sp_PDOStatement m_stmt;
public: Variant m_row;
public: int m_rowIndex;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment | IsProtected, 'return' => array('type' => null)));
DefineFunction(array('name' => "execute", 'desc' => "Execute the prepared statement. If the prepared statement included parameter markers, you must either: PDOStatement::bindParam() to bind PHP variables to the parameter markers: bound variables pass their value as input and receive the output value, if any, of their associated parameter markers", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "params", 'type' => VariantMap, 'value' => "null_array", 'desc' => "An array of values with as many elements as there are bound parameters in the SQL statement being executed. All values are treated as PDO::PARAM_STR.\n\nYou cannot bind multiple values to a single parameter; for example, you cannot bind two values to a single named parameter in an IN() clause."))));
DefineFunction(array('name' => "fetch", 'desc' => "Fetches a row from a result set associated with a PDOStatement object. The fetch_style parameter determines how PDO returns the row.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "The return value of this function on success depends on the fetch type. In all cases, FALSE is returned on failure."), 'args' => array(array('name' => "how", 'type' => Int64, 'value' => "0", 'desc' => "Controls how the next row will be returned to the caller. This value must be one of the PDO::FETCH_* constants, defaulting to PDO::FETCH_BOTH.\n\nPDO::FETCH_ASSOC: returns an array indexed by column name as returned in your result set\n\nPDO::FETCH_BOTH (default): returns an array indexed by both column name and 0-indexed column number as returned in your result set\n\nPDO::FETCH_BOUND: returns TRUE 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\n\nPDO::FETCH_CLASS: returns a new instance of the requested class, mapping the columns of the result set to named properties in the class. If fetch_style includes PDO::FETCH_CLASSTYPE (e.g. PDO::FETCH_CLASS | PDO::FETCH_CLASSTYPE) then the name of the class is determined from a value of the first column.\n\nPDO::FETCH_INTO: updates an existing instance of the requested class, mapping the columns of the result set to named properties in the class\n\nPDO::FETCH_LAZY: combines PDO::FETCH_BOTH and PDO::FETCH_OBJ, creating the object variable names as they are accessed\n\nPDO::FETCH_NUM: returns an array indexed by column number as returned in your result set, starting at column 0\n\nPDO::FETCH_OBJ: returns an anonymous object with property names that correspond to the column names returned in your result set"), array('name' => "orientation", 'type' => Int64, 'value' => "q_PDO\${$FETCH_ORI_NEXT}", 'desc' => "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 PDO::FETCH_ORI_* constants, defaulting to PDO::FETCH_ORI_NEXT. To request a scrollable cursor for your PDOStatement object, you must set the PDO::ATTR_CURSOR attribute to PDO::CURSOR_SCROLL when you prepare the SQL statement with PDO::prepare()."), array('name' => "offset", 'type' => Int64, 'value' => "0", 'desc' => "For a PDOStatement object representing a scrollable cursor for which the cursor_orientation parameter is set to PDO::FETCH_ORI_ABS, this value specifies the absolute number of the row in the result set that shall be fetched.\n\nFor a PDOStatement object representing a scrollable cursor for which the cursor_orientation parameter is set to PDO::FETCH_ORI_REL, this value specifies the row to fetch relative to the cursor position before PDOStatement::fetch() was called."))));
DefineFunction(array('name' => "fetchobject", 'desc' => "Fetches the next row and returns it as an object. This function is an alternative to PDOStatement::fetch() with PDO::FETCH_CLASS or PDO::FETCH_OBJ style.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns an instance of the required class with property names that correspond to the column names or FALSE on failure."), 'args' => array(array('name' => "class_name", 'type' => String, 'value' => "null_string", 'desc' => "Name of the created class."), array('name' => "ctor_args", 'type' => Variant, 'value' => "null", 'desc' => "Elements of this array are passed to the constructor."))));
DefineFunction(array('name' => "fetchcolumn", 'desc' => "Returns a single column from the next row of a result set or FALSE if there are no more rows.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "PDOStatement::fetchColumn() returns a single column in the next row of a result set. Warning\n\nThere is no way to return another column from the same row if you use PDOStatement::fetchColumn() to retrieve data."), 'args' => array(array('name' => "column_numner", 'type' => Int64, 'value' => "0", 'desc' => "0-indexed number of the column you wish to retrieve from the row. If no value is supplied, PDOStatement::fetchColumn() fetches the first column."))));
DefineFunction(array('name' => "fetchall", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "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.\n\nUsing 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 SORT BY clauses in SQL to restrict results before retrieving and processing them with PHP."), 'args' => array(array('name' => "how", 'type' => Int64, 'value' => "0", 'desc' => "Controls the contents of the returned array as documented in PDOStatement::fetch().\n\nTo return an array consisting of all values of a single column from the result set, specify PDO::FETCH_COLUMN. You can specify which column you want with the column-index parameter.\n\nTo fetch only the unique values of a single column from the result set, bitwise-OR PDO::FETCH_COLUMN with PDO::FETCH_UNIQUE.\n\nTo return an associative array grouped by the values of a specified column, bitwise-OR PDO::FETCH_COLUMN with PDO::FETCH_GROUP."), array('name' => "class_name", 'type' => Variant, 'value' => "null", 'desc' => "Returns the indicated 0-indexed column when the value of fetch_style is PDO::FETCH_COLUMN."), array('name' => "ctor_args", 'type' => Variant, 'value' => "null", 'desc' => "Arguments of custom class constructor."))));
DefineFunction(array('name' => "bindvalue", 'desc' => "Binds a value to a corresponding named or question mark placeholder in the SQL statement that was use to prepare the statement.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "paramno", 'type' => Variant, 'desc' => "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."), array('name' => "param", 'type' => Variant, 'desc' => "The value to bind to the parameter."), array('name' => "type", 'type' => Int64, 'value' => "q_PDO\${$PARAM_STR}", 'desc' => "Explicit data type for the parameter using the PDO::PARAM_* constants."))));
DefineFunction(array('name' => "bindparam", 'desc' => "Binds a PHP variable to a corresponding named or question mark placeholder in the SQL statement that was use 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.\n\nMost parameters are input parameters, that is, parameters that are used in a read-only fashion to build up the query. 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.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "paramno", 'type' => Variant, 'desc' => "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."), array('name' => "param", 'type' => Variant | Reference, 'desc' => "Name of the PHP variable to bind to the SQL statement parameter."), array('name' => "type", 'type' => Int64, 'value' => "q_PDO\${$PARAM_STR}", 'desc' => "Explicit data type for the parameter using the PDO::PARAM_* constants. To return an INOUT parameter from a stored procedure, use the bitwise OR operator to set the PDO::PARAM_INPUT_OUTPUT bits for the data_type parameter."), array('name' => "max_value_len", 'type' => Int64, 'value' => "0", 'desc' => "Length of the data type. To indicate that a parameter is an OUT parameter from a stored procedure, you must explicitly set the length."), array('name' => "driver_params", 'type' => Variant, 'value' => "null"))));
DefineFunction(array('name' => "bindcolumn", 'desc' => "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.\n\nSince information about the columns is not always available to PDO until the statement is executed, portable applications should call this function after PDOStatement::execute().\n\nHowever, 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.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "paramno", 'type' => Variant, 'desc' => "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."), array('name' => "param", 'type' => Variant | Reference, 'desc' => "Name of the PHP variable to which the column will be bound."), array('name' => "type", 'type' => Int64, 'value' => "q_PDO\${$PARAM_STR}", 'desc' => "Data type of the parameter, specified by the PDO::PARAM_* constants."), array('name' => "max_value_len", 'type' => Int64, 'value' => "0", 'desc' => "A hint for pre-allocation."), array('name' => "driver_params", 'type' => Variant, 'value' => "null", 'desc' => "Optional parameter(s) for the driver."))));
DefineFunction(array('name' => "rowcount", 'desc' => "PDOStatement::rowCount() returns the number of rows affected by the last DELETE, INSERT, or UPDATE statement executed by the corresponding PDOStatement object.\n\nIf the last SQL statement executed by the associated PDOStatement was a SELECT statement, some databases may return the number of rows returned by that statement. However, this behaviour is not guaranteed for all databases and should not be relied on for portable applications.", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns the number of rows.")));
DefineFunction(array('name' => "errorcode", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Identical to PDO::errorCode(), except that PDOStatement::errorCode() only retrieves error codes for operations performed with PDOStatement objects.")));
DefineFunction(array('name' => "errorinfo", 'flags' => HasDocComment, 'return' => array('type' => VariantVec, 'desc' => "PDOStatement::errorInfo() returns an array of error information about the last operation performed by this statement handle. The array consists of the following fields: Element Information 0 SQLSTATE error code (a five characters alphanumeric identifier defined in the ANSI SQL standard). 1 Driver specific error code. 2 Driver specific error message.")));
DefineFunction(array('name' => "__get", 'flags' => HasDocComment, 'return' => array('type' => Variant), 'args' => array(array('name' => "name", 'type' => Variant))));
DefineFunction(array('name' => "__set", 'flags' => HasDocComment, 'return' => array('type' => Variant), 'args' => array(array('name' => "name", 'type' => Variant), array('name' => "value", 'type' => Variant))));
DefineFunction(array('name' => "__isset", 'flags' => HasDocComment, 'return' => array('type' => Boolean), 'args' => array(array('name' => "name", 'type' => Variant))));
DefineFunction(array('name' => "__unset", 'flags' => HasDocComment, 'return' => array('type' => Variant), 'args' => array(array('name' => "name", 'type' => Variant))));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "LibXMLError", 'desc' => "Contains various information about errors thrown by libxml. The error codes are described within the official » xmlError API documentation.", 'flags' => HasDocComment));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "SimpleXMLElementIterator", 'ifaces' => array('Iterator'), 'bases' => array('Sweepable'), 'desc' => "", 'flags' => HasDocComment, 'footer' => <<<EOT
public:
void reset_iterator(c_SimpleXMLElement *parent);
c_SimpleXMLElement *m_parent;
ArrayIter *m_iter1;
ArrayIter *m_iter2;
Object m_temp;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "current", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "key", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "next", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "rewind", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "valid", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
// 'type' => type of the property
// 'flags' => attributes of the property
// 'desc' => description of the property
// 'note' => additional note about this property's schema
// )
//
// EndClass()
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "XMLReader", 'bases' => array('Sweepable'), 'desc' => "", 'flags' => HasDocComment, 'footer' => <<<EOT
private: String read_string_func(xmlreader_read_char_t internal_function);
private: bool bool_func_no_arg(xmlreader_read_int_t internal_function);
private: String string_func_string_arg(String value, xmlreader_read_one_char_t internal_function);
private: bool set_relaxng_schema(String source, int type);
public:
SmartObject<File> m_uri;
private:
xmlTextReaderPtr m_ptr;
xmlParserInputBufferPtr m_input;
void* m_schema;
EOT
));
DefineConstant(array('name' => "NONE", 'type' => Int64));
DefineConstant(array('name' => "ELEMENT", 'type' => Int64));
DefineConstant(array('name' => "ATTRIBUTE", 'type' => Int64));
DefineConstant(array('name' => "TEXT", 'type' => Int64));
DefineConstant(array('name' => "CDATA", 'type' => Int64));
DefineConstant(array('name' => "ENTITY_REF", 'type' => Int64));
DefineConstant(array('name' => "ENTITY", 'type' => Int64));
DefineConstant(array('name' => "PI", 'type' => Int64));
// 'flags' => attributes of the property
// 'desc' => description of the property
// 'note' => additional note about this property's schema
// )
//
// EndClass()
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "ImageSprite", 'bases' => array('Sweepable'), 'desc' => "Represents a set of images sprited into a single image.", 'flags' => HasDocComment, 'footer' => <<<EOT
private:
void map();
public:
hphp_string_map<ImageSprite::ResourceGroup*> m_rsrc_groups;
String m_image_string_buffer;
bool m_current;
hphp_string_map<ImageSprite::Image*> m_image_data;
Array m_mapping;
Array m_img_errors;
Array m_sprite_errors;
gdImagePtr m_image;
int m_width;
int m_height;
EOT
));
DefineFunction(array('name' => "__construct", 'desc' => "Creates a new ImageSprite object", 'flags' => HasDocComment, 'return' => array('type' => null, 'desc' => "TODO")));
DefineFunction(array('name' => "addFile", 'desc' => "Adds the image specified by the file path to the sprite.", 'flags' => HasDocComment, 'return' => array('type' => Object, 'desc' => "The ImageSprite object itself (for method chaining)."), 'args' => array(array('name' => "file", 'type' => String, 'desc' => "The path to the image. Must be a path to the local filesystem or a a stream format php supports."), array('name' => "options", 'type' => StringMap, 'value' => "null", 'desc' => "Associative array of options for this image. May include the image's 'width' and 'height' (if previously known to the developer), or spacing requirements via the padding_DIRECTION keys, where DIRECTION may be top, bottom, left, or right. May also include flush requirements that will force this image to be 'flush_left' or 'flush_right' within the sprite."))));
DefineFunction(array('name' => "addString", 'desc' => "Adds the image defined by the string to the sprite.", 'flags' => HasDocComment, 'return' => array('type' => Object, 'desc' => "The ImageSprite object itself (for method chaining)."), 'args' => array(array('name' => "id", 'type' => String, 'desc' => "An identifier for this image. This will be the key to referencing this image in the mapping."), array('name' => "data", 'type' => String, 'desc' => "The data of this image."), array('name' => "options", 'type' => StringMap, 'value' => "null", 'desc' => "Associative array of options for this image. May include the image's 'width' and 'height' (if previously known to the developer), or spacing requirements via the padding_DIRECTION keys, where DIRECTION may be top, bottom, left, or right. May also include flush requirements that will force this image to be 'flush_left' or 'flush_right' within the sprite."))));
DefineFunction(array('name' => "addUrl", 'desc' => "Adds the image located at the specified URL to the sprite.", 'flags' => HasDocComment, 'return' => array('type' => Object, 'desc' => "The ImageSprite object itself (for method chaining)."), 'args' => array(array('name' => "url", 'type' => String, 'desc' => "The url of the image. The URL must be using the http protocol; secure connections are not supported."), array('name' => "timeout_ms", 'type' => Int32, 'value' => "0", 'desc' => "The timeout in milliseconds for this request. A value of 0 or lower will disable the timeout."), array('name' => "Options", 'type' => StringMap, 'value' => "null", 'desc' => "Associative array of options for this image. May include the image's 'width' and 'height' (if previously known to the developer), or spacing requirements via the padding_DIRECTION keys, where DIRECTION may be top, bottom, left, or right. May also include flush requirements that will force this image to be 'flush_left' or 'flush_right' within the sprite."))));
DefineFunction(array('name' => "clear", 'desc' => "Removes images from the sprite and frees the memory associated with that image.", 'flags' => HasDocComment, 'return' => array('type' => Object, 'desc' => "The ImageSprite object itself (for method chaining)."), 'args' => array(array('name' => "paths", 'type' => Variant, 'value' => "null", 'desc' => "When passed a string, it will remove the images specified by that path or identifier from the sprite, if they exist. You may also pass an array of strings, and it will remove each. a null value will remove all images from the sprite."))));
DefineFunction(array('name' => "loadDims", 'desc' => "Loads the dimensions for the images in the sprite, but not necessarily their data.", 'flags' => HasDocComment, 'return' => array('type' => Object, 'desc' => "The ImageSprite object itself (for method chaining)."), 'args' => array(array('name' => "block", 'type' => Boolean, 'value' => "false", 'desc' => "Whether this call should block until all the data is loaded or allow them to load in the background."))));
DefineFunction(array('name' => "loadImages", 'desc' => "Loads the images in the sprite and sets the correct dimensions.", 'flags' => HasDocComment, 'return' => array('type' => Object, 'desc' => "The ImageSprite object itself (for method chaining)."), 'args' => array(array('name' => "block", 'type' => Boolean, 'value' => "false", 'desc' => "Whether this call should block until all the data is loaded or allow them to load in the background."))));
BeginClass(array('name' => 'GenericContinuation', 'parent' => 'Continuation', 'bases' => array('Sweepable'), 'flags' => NoDefaultSweep, 'footer' => <<<EOT
public:
HphpArray* getStaticLocals();
public:
TypedValue* m_locals;
bool m_hasExtraVars;
int m_nLocals;
Array m_vars;
intptr_t m_vmCalledClass; // Stored with 1 in its low bit
VM::Class* getVMCalledClass() {
return (VM::Class*)(m_vmCalledClass & ~0x1ll);
}
LVariableTable m_statics;
private:
SmartPtr<HphpArray> m_VMStatics;
EOT
));
DefineFunction(array('name' => '__construct', 'return' => array('type' => null), 'args' => array(array('name' => 'func', 'type' => Int64), array('name' => 'extra', 'type' => Int64), array('name' => 'isMethod', 'type' => Boolean), array('name' => 'origFuncName', 'type' => String), array('name' => 'vars', 'type' => VariantMap), array('name' => 'obj', 'type' => Variant, 'value' => 'null'), array('name' => 'args', 'type' => VariantMap, 'value' => 'null_array'))));
DefineFunction(array('name' => 'update', 'return' => array('type' => null), 'args' => array(array('name' => 'label', 'type' => Int64), array('name' => 'value', 'type' => Variant), array('name' => 'vars', 'type' => VariantMap))));
DefineFunction(array('name' => 'getVars', 'return' => array('type' => VariantMap)));
EndClass();
BeginClass(array('name' => "DummyContinuation", 'ifaces' => array('Iterator'), 'desc' => "Represents an invalid continuation which will fatal when used."));
DefineFunction(array('name' => '__construct', 'args' => array(), 'return' => array('type' => null)));
DefineFunction(array('name' => 'current', 'return' => array('type' => Variant)));
DefineFunction(array('name' => 'key', 'return' => array('type' => Int64)));
DefineFunction(array('name' => 'next', 'return' => array('type' => null)));
DefineFunction(array('name' => 'rewind', 'return' => array('type' => null)));
DefineFunction(array('name' => 'valid', 'return' => array('type' => Boolean)));
EndClass();
