* Convert object to a value * @return Value */

* The number of members in case of an array or object * @return int */

* Apply a number, and return a new value object after running the arithmetic function * @param value * @return Value */

* Retrieve the original value * @return Value */

* Find an extension based on the module number * @param number * @return Extension* */

* Retrieve the base class of the original C++ object * @return Base */

* Retrieve the value as integer * @return long */

* Retrieve our C++ implementation object * @param entry * @return ClassImpl */

* Rethrow the exception / make sure that it ends up in PHP space */

* Get access to a certain array member * @param index * @return Value */

* In case this is a reference, dereference it into a zval.. In case it isn't * the actual value is returned. * @return struct _zval_struct* */

* Retrieve a property by name * @param string * @return HashMember */

* Constructor * @param name Name of the argument * @param classname Name of the class * @param nullable Can it be nu

* Retrieve the value as decimal * @return double */

* Is the object locked? * * After the object is locked, no more elements can be added to it. * This happens after the call to get_mo

* Are we a float? This will also check if we're a reference to a float * @return bool */

* Retrieve the module pointer * * This is the memory address that should be exported by the get_module() * function. * * @return void* */

* Does the array contain a certain index? * @param index * @return bool */

* Return an iterator for iterating over the values * This is only meaningful for Value objects that hold an array or an object * @return iterator

* Retrieve the value as string * @return string */

* The type of object * @return Type */

* Get access to the raw buffer for read operations. Note that this * only works for string variables - other variables return nullptr. * * @retu

* Is this an existing hash member (true) or only one that is ready * to be assigned a new value to, but that is not yet in the hashtable *

* Add a property to the class * @param name Name of the property * @param value Actual property value * @param flags Opti

* Type-hint for the argument * @return Type */

* Add a ini entry to the extension implementation by moving it * @param ini The php.ini setting * @return Extension Same object to all

* Retrieve the data for the string * * @return Pointer to the string data */

* Detach the zval * * This will unlink the zval internal structure from the Value object, * so that the destructor will not reduce the number of

* Find the object based on a zval * @param val Zval object * @return ObjectImpl */

* Get access to a certain assoc member * @param key * @return Value */

* Set a certain property * @param index * @param value * @return Value */

* Does the file exist? * @return boolean */

* Retrieve the original implementation * * This only works for classes that were implemented using PHP-CPP, * it returns nullptr for all other c

* Are we a string? This will also check if we're a reference to a string * @return bool */

* Unset a member by its index * @param index */

* Helper function that runs the actual call * @param object The object to call it on * @param method The function or method to call

* Pointer to the PHP object * @return zend_object */

* Retrieve the value as boolean * @return bool */

* Initialize the class, given its name * * The module functions are registered on module startup, but classes are * initialized afterwards. The

* Are we a number? This will also check if we're a reference to a number * @return bool */

* The extension name * @return const char * */

* Is this a valid file? * @return boolean */

* Wrap around an object implemented by us * @param object Object to be wrapped */

* Function to test the Php::include_once() call * @param &params */

* Constructor * @param name Name of the argument * @param classname Name of the class * @param nullable Can it be nu

* Move constructor * @param that */

* Alternative constructor with just a filename * * @param name the filename */

* Return an iterator for iterating over the values * This is only meaningful for Value objects that hold an array or an object * @return iterator

* Call the method - if the variable holds an object with the given method * @param name name of the method to call * @return Value */

* call_php_function() * Calls a function in PHP space. * @param &params * @return Php::Value */

* Make a clone of the type * @return Value */

* Fetch the current item * * @param iter The iterator to retrieve the value from * @return The current value of the iterator */

* Execute the file * @return Value */

* Apply a callback to each registered function * * The callback will be called with the name of the namespace, and * a reference to the registe

* Copy constructor * * This copy constructor is explicitly defined to make sure that the * copied object does not already have an im

* Alternative constructor without a size * @param name Name of the PHP script * @param source PHP source code to be evaluat

* Add the constant to a class * * You normally do not have to call this method yourself. You can simply * do one of the following method calls

* Boolean value * @return bool */

* Construct a clone * @param orig * @return Base */

* Is a certain key set in the array * @param key * @return bool */

* Compare with other iterator * @param that * @return bool */

* The total number of functions * @return size_t */

* Initialize the extension after it was started * @param module_number * @return bool */

* Is a method with the given name callable? * * This is only applicable when the Value contains a PHP object * * @param name Name of th

* Are we null? This will also check if we're a reference to a null value * @return bool */

* Define the isset function */

* Retrieve pointer to our own object handlers * @return zend_object_handlers */

* Execute a file only once * @return Value */

* String value * @return std::string */

* Copy constructor * @param that */

* No copy'ing and no moving */

* No copying * @param that */

* Call a method * * This method is called when a method is called from the PHP script that * was not explicitly defined. You can use this to ca

* Compare the object with a different object * * Check how a different object compares to this object * * @param that Object to comp

* Overridable method that is called right before an object is destructed */

* Retrieve a property * * The default implementation does nothing, and the script will fall back * to accessing the regular object properties

* Call the class as if it was a function * * This method is called when a an object is used with () operators: * $object(). You can override th

* Overridable method that is called to check if a property is set * * The default implementation does nothing, and the script will fall back *

* Overridable method that is called to set a new property * * The default implementation does nothing, and the script will fall back * to acces

* Cast the object to a boolean * * This method is called when an object is casted to a bool, or when it * is used in a boolean context * *

* Cast the object to a float * * This method is called when an object is casted to a float, or when it * is used in a float context * * @re

* Cast the object to an integer * * This method is called when an object is casted to an integer, or when * it is used in an integer context *

* Cast the object to a string * * This method is called when an object is casted to a string, or when * it is used in a string context * *

* Remove a member * * The default implementation does nothing, and the script will fall back * to accessing the regular object properties *

* Add a library persistently * @param module */