return NULL;
} /* }}} */
-/* {{{ proto void DirectoryIterator::__construct(string path)
+/* {{{ proto void DirectoryIterator::__construct(string path) U
Cronstructs a new dir iterator from a path. */
SPL_METHOD(DirectoryIterator, __construct)
{
}
/* }}} */
-/* {{{ proto void DirectoryIterator::rewind()
+/* {{{ proto void DirectoryIterator::rewind() U
Rewind dir back to the start */
SPL_METHOD(DirectoryIterator, rewind)
{
}
/* }}} */
-/* {{{ proto string DirectoryIterator::key()
+/* {{{ proto string DirectoryIterator::key() U
Return current dir entry */
SPL_METHOD(DirectoryIterator, key)
{
}
/* }}} */
-/* {{{ proto DirectoryIterator DirectoryIterator::current()
+/* {{{ proto DirectoryIterator DirectoryIterator::current() U
Return this (needed for Iterator interface) */
SPL_METHOD(DirectoryIterator, current)
{
}
/* }}} */
-/* {{{ proto void DirectoryIterator::next()
+/* {{{ proto void DirectoryIterator::next() U
Move to next entry */
SPL_METHOD(DirectoryIterator, next)
{
}
/* }}} */
-/* {{{ proto string DirectoryIterator::valid()
+/* {{{ proto string DirectoryIterator::valid() U
Check whether dir contains more entries */
SPL_METHOD(DirectoryIterator, valid)
{
}
/* }}} */
-/* {{{ proto string SplFileInfo::getPath()
+/* {{{ proto string SplFileInfo::getPath() U
Return the path */
SPL_METHOD(SplFileInfo, getPath)
{
}
/* }}} */
-/* {{{ proto string SplFileInfo::getFilename()
+/* {{{ proto string SplFileInfo::getFilename() U
Return filename only */
SPL_METHOD(SplFileInfo, getFilename)
{
}
/* }}} */
-/* {{{ proto string DirectoryIterator::getFilename()
+/* {{{ proto string DirectoryIterator::getFilename() U
Return filename of current dir entry */
SPL_METHOD(DirectoryIterator, getFilename)
{
}
/* }}} */
-/* {{{ proto string SplFileInfo::getPathname()
+/* {{{ proto string SplFileInfo::getPathname() U
Return path and filename */
SPL_METHOD(SplFileInfo, getPathname)
{
}
/* }}} */
-/* {{{ proto string RecursiveDirectoryIterator::key()
+/* {{{ proto string RecursiveDirectoryIterator::key() U
Return getPathname() or getFilename() depending on flags */
SPL_METHOD(RecursiveDirectoryIterator, key)
{
}
/* }}} */
-/* {{{ proto string RecursiveDirectoryIterator::current()
+/* {{{ proto string RecursiveDirectoryIterator::current() U
Return getFilename(), getFileInfo() or $this depending on flags */
SPL_METHOD(RecursiveDirectoryIterator, current)
{
}
/* }}} */
-/* {{{ proto bool DirectoryIterator::isDot()
+/* {{{ proto bool DirectoryIterator::isDot() U
Returns true if current entry is '.' or '..' */
SPL_METHOD(DirectoryIterator, isDot)
{
}
/* }}} */
-/* {{{ proto void SplFileInfo::__construct(string file_name)
+/* {{{ proto void SplFileInfo::__construct(string file_name) U
Cronstructs a new SplFileInfo from a path. */
/* php_set_error_handling() is used to throw exceptions in case
the constructor fails. Here we use this to ensure the object
}
/* }}} */
-/* {{{ proto int SplFileInfo::getPerms()
+/* {{{ proto int SplFileInfo::getPerms() U
Get file permissions */
FileInfoFunction(getPerms, FS_PERMS)
/* }}} */
-/* {{{ proto int SplFileInfo::getInode()
+/* {{{ proto int SplFileInfo::getInode() U
Get file inode */
FileInfoFunction(getInode, FS_INODE)
/* }}} */
-/* {{{ proto int SplFileInfo::getSize()
+/* {{{ proto int SplFileInfo::getSize() U
Get file size */
FileInfoFunction(getSize, FS_SIZE)
/* }}} */
-/* {{{ proto int SplFileInfo::getOwner()
+/* {{{ proto int SplFileInfo::getOwner() U
Get file owner */
FileInfoFunction(getOwner, FS_OWNER)
/* }}} */
-/* {{{ proto int SplFileInfo::getGroup()
+/* {{{ proto int SplFileInfo::getGroup() U
Get file group */
FileInfoFunction(getGroup, FS_GROUP)
/* }}} */
-/* {{{ proto int SplFileInfo::getATime()
+/* {{{ proto int SplFileInfo::getATime() U
Get last access time of file */
FileInfoFunction(getATime, FS_ATIME)
/* }}} */
-/* {{{ proto int SplFileInfo::getMTime()
+/* {{{ proto int SplFileInfo::getMTime() U
Get last modification time of file */
FileInfoFunction(getMTime, FS_MTIME)
/* }}} */
-/* {{{ proto int SplFileInfo::getCTime()
+/* {{{ proto int SplFileInfo::getCTime() U
Get inode modification time of file */
FileInfoFunction(getCTime, FS_CTIME)
/* }}} */
-/* {{{ proto string SplFileInfo::getType()
+/* {{{ proto string SplFileInfo::getType() U
Get file type */
FileInfoFunction(getType, FS_TYPE)
/* }}} */
-/* {{{ proto bool SplFileInfo::isWritable()
+/* {{{ proto bool SplFileInfo::isWritable() U
Returns true if file can be written */
FileInfoFunction(isWritable, FS_IS_W)
/* }}} */
-/* {{{ proto bool SplFileInfo::isReadable()
+/* {{{ proto bool SplFileInfo::isReadable() U
Returns true if file can be read */
FileInfoFunction(isReadable, FS_IS_R)
/* }}} */
-/* {{{ proto bool SplFileInfo::isExecutable()
+/* {{{ proto bool SplFileInfo::isExecutable() U
Returns true if file is executable */
FileInfoFunction(isExecutable, FS_IS_X)
/* }}} */
-/* {{{ proto bool SplFileInfo::isFile()
+/* {{{ proto bool SplFileInfo::isFile() U
Returns true if file is a regular file */
FileInfoFunction(isFile, FS_IS_FILE)
/* }}} */
-/* {{{ proto bool SplFileInfo::isDir()
+/* {{{ proto bool SplFileInfo::isDir() U
Returns true if file is directory */
FileInfoFunction(isDir, FS_IS_DIR)
/* }}} */
-/* {{{ proto bool SplFileInfo::isLink()
+/* {{{ proto bool SplFileInfo::isLink() U
Returns true if file is symbolic link */
FileInfoFunction(isLink, FS_IS_LINK)
/* }}} */
-/* {{{ proto SplFileObject SplFileInfo::openFile([string mode = 'r' [, bool use_include_path [, resource context]]])
+/* {{{ proto SplFileObject SplFileInfo::openFile([string mode = 'r' [, bool use_include_path [, resource context]]]) U
Open the current file */
SPL_METHOD(SplFileInfo, openFile)
{
}
/* }}} */
-/* {{{ proto void SplFileInfo::setFileClass([string class_name])
+/* {{{ proto void SplFileInfo::setFileClass([string class_name]) U
Class to use in openFile() */
SPL_METHOD(SplFileInfo, setFileClass)
{
}
/* }}} */
-/* {{{ proto void SplFileInfo::setInfoClass([string class_name])
+/* {{{ proto void SplFileInfo::setInfoClass([string class_name]) U
Class to use in getFileInfo(), getPathInfo() */
SPL_METHOD(SplFileInfo, setInfoClass)
{
}
/* }}} */
-/* {{{ proto SplFileInfo SplFileInfo::getFileInfo([string $class_name])
+/* {{{ proto SplFileInfo SplFileInfo::getFileInfo([string $class_name]) U
Get/copy file info */
SPL_METHOD(SplFileInfo, getFileInfo)
{
}
/* }}} */
-/* {{{ proto SplFileInfo SplFileInfo::getPathInfo([string $class_name])
+/* {{{ proto SplFileInfo SplFileInfo::getPathInfo([string $class_name]) U
Get/copy file info */
SPL_METHOD(SplFileInfo, getPathInfo)
{
}
/* }}} */
-/* {{{ proto void RecursiveDirectoryIterator::__construct(string path [, int flags])
+/* {{{ proto void RecursiveDirectoryIterator::__construct(string path [, int flags]) U
Cronstructs a new dir iterator from a path. */
SPL_METHOD(RecursiveDirectoryIterator, __construct)
{
}
/* }}} */
-/* {{{ proto void RecursiveDirectoryIterator::rewind()
+/* {{{ proto void RecursiveDirectoryIterator::rewind() U
Rewind dir back to the start */
SPL_METHOD(RecursiveDirectoryIterator, rewind)
{
}
/* }}} */
-/* {{{ proto void RecursiveDirectoryIterator::next()
+/* {{{ proto void RecursiveDirectoryIterator::next() U
Move to next entry */
SPL_METHOD(RecursiveDirectoryIterator, next)
{
}
/* }}} */
-/* {{{ proto bool RecursiveDirectoryIterator::hasChildren([bool $allow_links = false])
+/* {{{ proto bool RecursiveDirectoryIterator::hasChildren([bool $allow_links = false]) U
Returns whether current entry is a directory and not '.' or '..' */
SPL_METHOD(RecursiveDirectoryIterator, hasChildren)
{
}
/* }}} */
-/* {{{ proto RecursiveDirectoryIterator DirectoryIterator::getChildren()
+/* {{{ proto RecursiveDirectoryIterator DirectoryIterator::getChildren() U
Returns an iterator for the current entry if it is a directory */
SPL_METHOD(RecursiveDirectoryIterator, getChildren)
{
}
/* }}} */
-/* {{{ proto void RecursiveDirectoryIterator::getSubPath()
+/* {{{ proto void RecursiveDirectoryIterator::getSubPath() U
Get sub path */
SPL_METHOD(RecursiveDirectoryIterator, getSubPath)
{
}
/* }}} */
-/* {{{ proto void RecursiveDirectoryIterator::getSubPathname()
+/* {{{ proto void RecursiveDirectoryIterator::getSubPathname() U
Get sub path and file name */
SPL_METHOD(RecursiveDirectoryIterator, getSubPathname)
{
}
} /* }}} */
-/* {{{ proto void SplFileObject::__construct(string filename [, string mode = 'r' [, bool use_include_path [, resource context]]]])
+/* {{{ proto void SplFileObject::__construct(string filename [, string mode = 'r' [, bool use_include_path [, resource context]]]]) U
Construct a new file object */
SPL_METHOD(SplFileObject, __construct)
{
php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC);
} /* }}} */
-/* {{{ proto void SplTempFileObject::__construct([int max_memory])
+/* {{{ proto void SplTempFileObject::__construct([int max_memory]) U
Construct a new temp file object */
SPL_METHOD(SplTempFileObject, __construct)
{
php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC);
} /* }}} */
-/* {{{ proto void SplFileObject::rewind()
+/* {{{ proto void SplFileObject::rewind() U
Rewind the file and read the first line */
SPL_METHOD(SplFileObject, rewind)
{
spl_filesystem_file_rewind(getThis(), intern TSRMLS_CC);
} /* }}} */
-/* {{{ proto void SplFileObject::eof()
+/* {{{ proto void SplFileObject::eof() U
Return whether end of file is reached */
SPL_METHOD(SplFileObject, eof)
{
RETURN_BOOL(php_stream_eof(intern->u.file.stream));
} /* }}} */
-/* {{{ proto void SplFileObject::valid()
+/* {{{ proto void SplFileObject::valid() U
Return !eof() */
SPL_METHOD(SplFileObject, valid)
{
}
} /* }}} */
-/* {{{ proto string SplFileObject::fgets()
+/* {{{ proto string SplFileObject::fgets() U
Rturn next line from file */
SPL_METHOD(SplFileObject, fgets)
{
RETURN_STRINGL(intern->u.file.current_line, intern->u.file.current_line_len, 1);
} /* }}} */
-/* {{{ proto string SplFileObject::current()
+/* {{{ proto string SplFileObject::current() U
Return current line from file */
SPL_METHOD(SplFileObject, current)
{
RETURN_FALSE;
} /* }}} */
-/* {{{ proto int SplFileObject::key()
+/* {{{ proto int SplFileObject::key() U
Return line number */
SPL_METHOD(SplFileObject, key)
{
RETURN_LONG(intern->u.file.current_line_num);
} /* }}} */
-/* {{{ proto void SplFileObject::next()
+/* {{{ proto void SplFileObject::next() U
Read next line */
SPL_METHOD(SplFileObject, next)
{
intern->u.file.current_line_num++;
} /* }}} */
-/* {{{ proto void SplFileObject::setFlags(int flags)
+/* {{{ proto void SplFileObject::setFlags(int flags) U
Set file handling flags */
SPL_METHOD(SplFileObject, setFlags)
{
zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &intern->flags);
} /* }}} */
-/* {{{ proto int SplFileObject::getFlags()
+/* {{{ proto int SplFileObject::getFlags() U
Get file handling flags */
SPL_METHOD(SplFileObject, getFlags)
{
RETURN_LONG(intern->flags);
} /* }}} */
-/* {{{ proto void SplFileObject::setMaxLineLen(int max_len)
+/* {{{ proto void SplFileObject::setMaxLineLen(int max_len) U
Set maximum line length */
SPL_METHOD(SplFileObject, setMaxLineLen)
{
intern->u.file.max_line_len = max_len;
} /* }}} */
-/* {{{ proto int SplFileObject::getMaxLineLen()
+/* {{{ proto int SplFileObject::getMaxLineLen() U
Get maximum line length */
SPL_METHOD(SplFileObject, getMaxLineLen)
{
RETURN_LONG((long)intern->u.file.max_line_len);
} /* }}} */
-/* {{{ proto bool SplFileObject::hasChildren()
+/* {{{ proto bool SplFileObject::hasChildren() U
Return false */
SPL_METHOD(SplFileObject, hasChildren)
{
RETURN_FALSE;
} /* }}} */
-/* {{{ proto bool SplFileObject::getChildren()
+/* {{{ proto bool SplFileObject::getChildren() U
Read NULL */
SPL_METHOD(SplFileObject, getChildren)
{
}
/* }}} */
-/* {{{ proto array SplFileObject::fgetcsv([string delimiter [, string enclosure]])
+/* {{{ proto array SplFileObject::fgetcsv([string delimiter [, string enclosure]]) U
Return current line as csv */
SPL_METHOD(SplFileObject, fgetcsv)
{
}
/* }}} */
-/* {{{ proto array SplFileObject::getCsvControl()
+/* {{{ proto array SplFileObject::getCsvControl() U
Get the delimiter and enclosure character used in fgetcsv */
SPL_METHOD(SplFileObject, getCsvControl)
{
FileFunction(flock)
/* }}} */
-/* {{{ proto bool SplFileObject::fflush()
+/* {{{ proto bool SplFileObject::fflush() U
Flush the file */
SPL_METHOD(SplFileObject, fflush)
{
} /* }}} */
-/* {{{ proto int SplFileObject::ftell()
+/* {{{ proto int SplFileObject::ftell() U
Return current file position */
SPL_METHOD(SplFileObject, ftell)
{
}
} /* }}} */
-/* {{{ proto int SplFileObject::fseek(int pos [, int whence = SEEK_SET])
+/* {{{ proto int SplFileObject::fseek(int pos [, int whence = SEEK_SET]) U
Return current file position */
SPL_METHOD(SplFileObject, fseek)
{
RETURN_LONG(php_stream_seek(intern->u.file.stream, pos, whence));
} /* }}} */
-/* {{{ proto int SplFileObject::fgetc()
+/* {{{ proto int SplFileObject::fgetc() U
Get a character form the file */
SPL_METHOD(SplFileObject, fgetc)
{
}
} /* }}} */
-/* {{{ proto string SplFileObject::fgetss([string allowable_tags])
+/* {{{ proto string SplFileObject::fgetss([string allowable_tags]) U
Get a line from file pointer and strip HTML tags */
SPL_METHOD(SplFileObject, fgetss)
{
zval_ptr_dtor(&arg2);
} /* }}} */
-/* {{{ proto int SplFileObject::fpassthru()
+/* {{{ proto int SplFileObject::fpassthru() U
Output all remaining data from a file pointer */
SPL_METHOD(SplFileObject, fpassthru)
{
RETURN_LONG(php_stream_passthru(intern->u.file.stream));
} /* }}} */
-/* {{{ proto bool SplFileObject::fscanf(string format [, string ...])
+/* {{{ proto bool SplFileObject::fscanf(string format [, string ...]) U
Implements a mostly ANSI compatible fscanf() */
SPL_METHOD(SplFileObject, fscanf)
{
}
/* }}} */
-/* {{{ proto mixed SplFileObject::fwrite(string str [, int length])
+/* {{{ proto mixed SplFileObject::fwrite(string str [, int length]) U
Binary-safe file write */
SPL_METHOD(SplFileObject, fwrite)
{
FileFunction(fstat)
/* }}} */
-/* {{{ proto bool SplFileObject::ftruncate(int size)
+/* {{{ proto bool SplFileObject::ftruncate(int size) U
Truncate file to 'size' length */
SPL_METHOD(SplFileObject, ftruncate)
{
spl_recursive_it_rewind
};
-/* {{{ proto void RecursiveIteratorIterator::__construct(RecursiveIterator|IteratorAggregate it [, int mode = RIT_LEAVES_ONLY [, int flags = 0]]) throws InvalidArgumentException
+/* {{{ proto void RecursiveIteratorIterator::__construct(RecursiveIterator|IteratorAggregate it [, int mode = RIT_LEAVES_ONLY [, int flags = 0]]) throws InvalidArgumentException U
Creates a RecursiveIteratorIterator from a RecursiveIterator. */
SPL_METHOD(RecursiveIteratorIterator, __construct)
{
php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC);
} /* }}} */
-/* {{{ proto void RecursiveIteratorIterator::rewind()
+/* {{{ proto void RecursiveIteratorIterator::rewind() U
Rewind the iterator to the first element of the top level inner iterator. */
SPL_METHOD(RecursiveIteratorIterator, rewind)
{
spl_recursive_it_rewind_ex(object, getThis() TSRMLS_CC);
} /* }}} */
-/* {{{ proto bool RecursiveIteratorIterator::valid()
+/* {{{ proto bool RecursiveIteratorIterator::valid() U
Check whether the current position is valid */
SPL_METHOD(RecursiveIteratorIterator, valid)
{
RETURN_BOOL(spl_recursive_it_valid_ex(object, getThis() TSRMLS_CC) == SUCCESS);
} /* }}} */
-/* {{{ proto mixed RecursiveIteratorIterator::key()
+/* {{{ proto mixed RecursiveIteratorIterator::key() U
Access the current key */
SPL_METHOD(RecursiveIteratorIterator, key)
{
}
} /* }}} */
-/* {{{ proto mixed RecursiveIteratorIterator::current()
+/* {{{ proto mixed RecursiveIteratorIterator::current() U
Access the current element value */
SPL_METHOD(RecursiveIteratorIterator, current)
{
RETURN_ZVAL(*data, 1, 0);
} /* }}} */
-/* {{{ proto void RecursiveIteratorIterator::next()
+/* {{{ proto void RecursiveIteratorIterator::next() U
Move forward to the next element */
SPL_METHOD(RecursiveIteratorIterator, next)
{
spl_recursive_it_move_forward_ex(object, getThis() TSRMLS_CC);
} /* }}} */
-/* {{{ proto int RecursiveIteratorIterator::getDepth()
+/* {{{ proto int RecursiveIteratorIterator::getDepth() U
Get the current depth of the recursive iteration */
SPL_METHOD(RecursiveIteratorIterator, getDepth)
{
RETURN_LONG(object->level);
} /* }}} */
-/* {{{ proto RecursiveIterator RecursiveIteratorIterator::getSubIterator([int level])
+/* {{{ proto RecursiveIterator RecursiveIteratorIterator::getSubIterator([int level]) U
The current active sub iterator or the iterator at specified level */
SPL_METHOD(RecursiveIteratorIterator, getSubIterator)
{
RETURN_ZVAL(object->iterators[level].zobject, 1, 0);
} /* }}} */
-/* {{{ proto RecursiveIterator RecursiveIteratorIterator::getInnerIterator()
+/* {{{ proto RecursiveIterator RecursiveIteratorIterator::getInnerIterator() U
The current active sub iterator */
SPL_METHOD(RecursiveIteratorIterator, getInnerIterator)
{
RETURN_ZVAL(object->iterators[level].zobject, 1, 0);
} /* }}} */
-/* {{{ proto RecursiveIterator RecursiveIteratorIterator::beginIteration()
+/* {{{ proto RecursiveIterator RecursiveIteratorIterator::beginIteration() U
Called when iteration begins (after first rewind() call) */
SPL_METHOD(RecursiveIteratorIterator, beginIteration)
{
/* nothing to do */
} /* }}} */
-/* {{{ proto RecursiveIterator RecursiveIteratorIterator::endIteration()
+/* {{{ proto RecursiveIterator RecursiveIteratorIterator::endIteration() U
Called when iteration ends (when valid() first returns false */
SPL_METHOD(RecursiveIteratorIterator, endIteration)
{
/* nothing to do */
} /* }}} */
-/* {{{ proto bool RecursiveIteratorIterator::callHasChildren()
+/* {{{ proto bool RecursiveIteratorIterator::callHasChildren() U
Called for each element to test whether it has children */
SPL_METHOD(RecursiveIteratorIterator, callHasChildren)
{
}
} /* }}} */
-/* {{{ proto RecursiveIterator RecursiveIteratorIterator::callGetChildren()
+/* {{{ proto RecursiveIterator RecursiveIteratorIterator::callGetChildren() U
Return children of current element */
SPL_METHOD(RecursiveIteratorIterator, callGetChildren)
{
}
} /* }}} */
-/* {{{ proto void RecursiveIteratorIterator::beginChildren()
+/* {{{ proto void RecursiveIteratorIterator::beginChildren() U
Called when recursing one level down */
SPL_METHOD(RecursiveIteratorIterator, beginChildren)
{
/* nothing to do */
} /* }}} */
-/* {{{ proto void RecursiveIteratorIterator::endChildren()
+/* {{{ proto void RecursiveIteratorIterator::endChildren() U
Called when end recursing one level */
SPL_METHOD(RecursiveIteratorIterator, endChildren)
{
/* nothing to do */
} /* }}} */
-/* {{{ proto void RecursiveIteratorIterator::nextElement()
+/* {{{ proto void RecursiveIteratorIterator::nextElement() U
Called when the next element is available */
SPL_METHOD(RecursiveIteratorIterator, nextElement)
{
/* nothing to do */
} /* }}} */
-/* {{{ proto void RecursiveIteratorIterator::setMaxDepth([$max_depth = -1])
+/* {{{ proto void RecursiveIteratorIterator::setMaxDepth([$max_depth = -1]) U
Set the maximum allowed depth (or any depth if pmax_depth = -1] */
SPL_METHOD(RecursiveIteratorIterator, setMaxDepth)
{
object->max_depth = max_depth;
} /* }}} */
-/* {{{ proto int|false RecursiveIteratorIterator::getMaxDepth()
+/* {{{ proto int|false RecursiveIteratorIterator::getMaxDepth() U
Return the maximum accepted depth or false if any depth is allowed */
SPL_METHOD(RecursiveIteratorIterator, getMaxDepth)
{
char * class_name;
int class_name_len;
+ /* UTODO: class_name must be zstr */
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|s", &zobject, ce_inner, &class_name, &class_name_len) == FAILURE) {
php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC);
return NULL;
intern->u.regex.use_flags = ZEND_NUM_ARGS() >= 5;
intern->u.regex.flags = 0;
intern->u.regex.preg_flags = 0;
+ /* UTODO: do we need tocare if regex unicode? */
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os|lll", &zobject, ce_inner, ®ex, ®ex_len, &mode, &intern->u.regex.flags, &intern->u.regex.preg_flags) == FAILURE) {
php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC);
return NULL;
return intern;
}
-/* {{{ proto void FilterIterator::__construct(Iterator it)
+/* {{{ proto void FilterIterator::__construct(Iterator it) U
Create an Iterator from another iterator */
SPL_METHOD(FilterIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_FilterIterator, zend_ce_iterator, DIT_FilterIterator);
} /* }}} */
-/* {{{ proto Iterator FilterIterator::getInnerIterator()
- proto Iterator CachingIterator::getInnerIterator()
- proto Iterator LimitIterator::getInnerIterator()
- proto Iterator ParentIterator::getInnerIterator()
+/* {{{ proto Iterator FilterIterator::getInnerIterator() U
+ proto Iterator CachingIterator::getInnerIterator() U
+ proto Iterator LimitIterator::getInnerIterator() U
+ proto Iterator ParentIterator::getInnerIterator() U
Get the inner iterator */
SPL_METHOD(dual_it, getInnerIterator)
{
spl_dual_it_fetch(intern, 1 TSRMLS_CC);
} /* }}} */
-/* {{{ proto bool FilterIterator::valid()
- proto bool ParentIterator::valid()
- proto bool IteratorIterator::valid()
- proto bool NoRewindIterator::valid()
+/* {{{ proto bool FilterIterator::valid() U
+ proto bool ParentIterator::valid() U
+ proto bool IteratorIterator::valid() U
+ proto bool NoRewindIterator::valid() U
Check whether the current element is valid */
SPL_METHOD(dual_it, valid)
{
RETURN_BOOL(intern->current.data);
} /* }}} */
-/* {{{ proto mixed FilterIterator::key()
- proto mixed CachingIterator::key()
- proto mixed LimitIterator::key()
- proto mixed ParentIterator::key()
- proto mixed IteratorIterator::key()
- proto mixed NoRewindIterator::key()
- proto mixed AppendIterator::key()
+/* {{{ proto mixed FilterIterator::key() U
+ proto mixed CachingIterator::key() U
+ proto mixed LimitIterator::key() U
+ proto mixed ParentIterator::key() U
+ proto mixed IteratorIterator::key() U
+ proto mixed NoRewindIterator::key() U
+ proto mixed AppendIterator::key() U
Get the current key */
SPL_METHOD(dual_it, key)
{
RETURN_NULL();
} /* }}} */
-/* {{{ proto mixed FilterIterator::current()
- proto mixed CachingIterator::current()
- proto mixed LimitIterator::current()
- proto mixed ParentIterator::current()
- proto mixed IteratorIterator::current()
- proto mixed NoRewindIterator::current()
- proto mixed AppendIterator::current()
+/* {{{ proto mixed FilterIterator::current() U
+ proto mixed CachingIterator::current() U
+ proto mixed LimitIterator::current() U
+ proto mixed ParentIterator::current() U
+ proto mixed IteratorIterator::current() U
+ proto mixed NoRewindIterator::current() U
+ proto mixed AppendIterator::current() U
Get the current element value */
SPL_METHOD(dual_it, current)
{
}
} /* }}} */
-/* {{{ proto void ParentIterator::next()
- proto void IteratorIterator::next()
- proto void NoRewindIterator::next()
+/* {{{ proto void ParentIterator::next() U
+ proto void IteratorIterator::next() U
+ proto void NoRewindIterator::next() U
Move the iterator forward */
SPL_METHOD(dual_it, next)
{
spl_filter_it_fetch(zthis, intern TSRMLS_CC);
}
-/* {{{ proto void FilterIterator::rewind()
+/* {{{ proto void FilterIterator::rewind() U
Rewind the iterator */
SPL_METHOD(FilterIterator, rewind)
{
spl_filter_it_rewind(getThis(), intern TSRMLS_CC);
} /* }}} */
-/* {{{ proto void FilterIterator::next()
+/* {{{ proto void FilterIterator::next() U
Move the iterator forward */
SPL_METHOD(FilterIterator, next)
{
spl_filter_it_next(getThis(), intern TSRMLS_CC);
} /* }}} */
-/* {{{ proto void RecursiveFilterIterator::__construct(RecursiveIterator it)
+/* {{{ proto void RecursiveFilterIterator::__construct(RecursiveIterator it) U
Create a RecursiveFilterIterator from a RecursiveIterator */
SPL_METHOD(RecursiveFilterIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveFilterIterator, spl_ce_RecursiveIterator, DIT_RecursiveFilterIterator);
} /* }}} */
-/* {{{ proto bool RecursiveFilterIterator::hasChildren()
+/* {{{ proto bool RecursiveFilterIterator::hasChildren() U
Check whether the inner iterator's current element has children */
SPL_METHOD(RecursiveFilterIterator, hasChildren)
{
}
} /* }}} */
-/* {{{ proto RecursiveFilterIterator RecursiveFilterIterator::getChildren()
+/* {{{ proto RecursiveFilterIterator RecursiveFilterIterator::getChildren() U
Return the inner iterator's children contained in a RecursiveFilterIterator */
SPL_METHOD(RecursiveFilterIterator, getChildren)
{
}
} /* }}} */
-/* {{{ proto void ParentIterator::__construct(RecursiveIterator it)
+/* {{{ proto void ParentIterator::__construct(RecursiveIterator it) U
Create a ParentIterator from a RecursiveIterator */
SPL_METHOD(ParentIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_ParentIterator, spl_ce_RecursiveIterator, DIT_ParentIterator);
} /* }}} */
-/* {{{ proto bool ParentIterator::hasChildren()
+/* {{{ proto bool ParentIterator::hasChildren() U
Check whether the inner iterator's current element has children */
SPL_METHOD(ParentIterator, hasChildren)
{
}
} /* }}} */
-/* {{{ proto ParentIterator ParentIterator::getChildren()
+/* {{{ proto ParentIterator ParentIterator::getChildren() U
Return the inner iterator's children contained in a ParentIterator */
SPL_METHOD(ParentIterator, getChildren)
{
} /* }}} */
#if HAVE_PCRE || HAVE_BUNDLED_PCRE
-/* {{{ proto void RegexIterator::__construct(Iterator it, string regex [, int mode [, int flags [, int preg_flags]]])
+/* {{{ proto void RegexIterator::__construct(Iterator it, string regex [, int mode [, int flags [, int preg_flags]]]) U
Create an RegexIterator from another iterator and a regular expression */
SPL_METHOD(RegexIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RegexIterator, zend_ce_iterator, DIT_RegexIterator);
} /* }}} */
-/* {{{ proto bool RegexIterator::accept()
+/* {{{ proto bool RegexIterator::accept() U
Match (string)current() against regular expression */
SPL_METHOD(RegexIterator, accept)
{
}
} /* }}} */
-/* {{{ proto bool RegexIterator::getMode()
+/* {{{ proto bool RegexIterator::getMode() U
Returns current operation mode */
SPL_METHOD(RegexIterator, getMode)
{
RETURN_LONG(intern->u.regex.mode);
} /* }}} */
-/* {{{ proto bool RegexIterator::setMode(int new_mode)
+/* {{{ proto bool RegexIterator::setMode(int new_mode) U
Set new operation mode */
SPL_METHOD(RegexIterator, setMode)
{
intern->u.regex.mode = mode;
} /* }}} */
-/* {{{ proto bool RegexIterator::getFlags()
+/* {{{ proto bool RegexIterator::getFlags() U
Returns current operation flags */
SPL_METHOD(RegexIterator, getFlags)
{
RETURN_LONG(intern->u.regex.flags);
} /* }}} */
-/* {{{ proto bool RegexIterator::setFlags(int new_flags)
+/* {{{ proto bool RegexIterator::setFlags(int new_flags) U
Set operation flags */
SPL_METHOD(RegexIterator, setFlags)
{
intern->u.regex.flags = flags;
} /* }}} */
-/* {{{ proto bool RegexIterator::getFlags()
+/* {{{ proto bool RegexIterator::getFlags() U
Returns current PREG flags (if in use or NULL) */
SPL_METHOD(RegexIterator, getPregFlags)
{
}
} /* }}} */
-/* {{{ proto bool RegexIterator::setPregFlags(int new_flags)
+/* {{{ proto bool RegexIterator::setPregFlags(int new_flags) U
Set PREG flags */
SPL_METHOD(RegexIterator, setPregFlags)
{
intern->u.regex.use_flags = 1;
} /* }}} */
-/* {{{ proto void RecursiveRegexIterator::__construct(RecursiveIterator it, string regex [, int mode [, int flags [, int preg_flags]]])
+/* {{{ proto void RecursiveRegexIterator::__construct(RecursiveIterator it, string regex [, int mode [, int flags [, int preg_flags]]]) U
Create an RecursiveRegexIterator from another recursive iterator and a regular expression */
SPL_METHOD(RecursiveRegexIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveRegexIterator, spl_ce_RecursiveIterator, DIT_RecursiveRegexIterator);
} /* }}} */
-/* {{{ proto RecursiveRegexIterator RecursiveRegexIterator::getChildren()
+/* {{{ proto RecursiveRegexIterator RecursiveRegexIterator::getChildren() U
Return the inner iterator's children contained in a RecursiveRegexIterator */
SPL_METHOD(RecursiveRegexIterator, getChildren)
{
}
}
-/* {{{ proto LimitIterator::__construct(Iterator it [, int offset, int count])
+/* {{{ proto LimitIterator::__construct(Iterator it [, int offset, int count]) U
Construct a LimitIterator from an Iterator with a given starting offset and optionally a maximum count */
SPL_METHOD(LimitIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_LimitIterator, zend_ce_iterator, DIT_LimitIterator);
} /* }}} */
-/* {{{ proto void LimitIterator::rewind()
+/* {{{ proto void LimitIterator::rewind() U
Rewind the iterator to the specified starting offset */
SPL_METHOD(LimitIterator, rewind)
{
spl_limit_it_seek(intern, intern->u.limit.offset TSRMLS_CC);
} /* }}} */
-/* {{{ proto bool LimitIterator::valid()
+/* {{{ proto bool LimitIterator::valid() U
Check whether the current element is valid */
SPL_METHOD(LimitIterator, valid)
{
RETURN_BOOL((intern->u.limit.count == -1 || intern->current.pos < intern->u.limit.offset + intern->u.limit.count) && intern->current.data);
} /* }}} */
-/* {{{ proto void LimitIterator::next()
+/* {{{ proto void LimitIterator::next() U
Move the iterator forward */
SPL_METHOD(LimitIterator, next)
{
}
} /* }}} */
-/* {{{ proto void LimitIterator::seek(int position)
+/* {{{ proto void LimitIterator::seek(int position) U
Seek to the given position */
SPL_METHOD(LimitIterator, seek)
{
RETURN_LONG(intern->current.pos);
} /* }}} */
-/* {{{ proto int LimitIterator::getPosition()
+/* {{{ proto int LimitIterator::getPosition() U
Return the current position */
SPL_METHOD(LimitIterator, getPosition)
{
spl_caching_it_next(intern TSRMLS_CC);
}
-/* {{{ proto void CachingIterator::__construct(Iterator it [, flags = CIT_CALL_TOSTRING])
+/* {{{ proto void CachingIterator::__construct(Iterator it [, flags = CIT_CALL_TOSTRING]) U
Construct a CachingIterator from an Iterator */
SPL_METHOD(CachingIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_CachingIterator, zend_ce_iterator, DIT_CachingIterator);
} /* }}} */
-/* {{{ proto void CachingIterator::rewind()
+/* {{{ proto void CachingIterator::rewind() U
Rewind the iterator */
SPL_METHOD(CachingIterator, rewind)
{
spl_caching_it_rewind(intern TSRMLS_CC);
} /* }}} */
-/* {{{ proto bool CachingIterator::valid()
+/* {{{ proto bool CachingIterator::valid() U
Check whether the current element is valid */
SPL_METHOD(CachingIterator, valid)
{
RETURN_BOOL(spl_caching_it_valid(intern TSRMLS_CC) == SUCCESS);
} /* }}} */
-/* {{{ proto void CachingIterator::next()
+/* {{{ proto void CachingIterator::next() U
Move the iterator forward */
SPL_METHOD(CachingIterator, next)
{
spl_caching_it_next(intern TSRMLS_CC);
} /* }}} */
-/* {{{ proto bool CachingIterator::hasNext()
+/* {{{ proto bool CachingIterator::hasNext() U
Check whether the inner iterator has a valid next element */
SPL_METHOD(CachingIterator, hasNext)
{
RETURN_BOOL(spl_caching_it_has_next(intern TSRMLS_CC) == SUCCESS);
} /* }}} */
-/* {{{ proto string CachingIterator::__toString()
+/* {{{ proto string CachingIterator::__toString() U
Return the string representation of the current element */
SPL_METHOD(CachingIterator, __toString)
{
}
} /* }}} */
-/* {{{ proto void CachingIterator::offsetSet(mixed index, mixed newval)
+/* {{{ proto void CachingIterator::offsetSet(mixed index, mixed newval) U
Set given index in cache */
SPL_METHOD(CachingIterator, offsetSet)
{
}
/* }}} */
-/* {{{ proto string CachingIterator::offsetGet(mixed index)
+/* {{{ proto string CachingIterator::offsetGet(mixed index) U
Return the internal cache if used */
SPL_METHOD(CachingIterator, offsetGet)
{
}
/* }}} */
-/* {{{ proto void CachingIterator::offsetUnset(mixed index)
+/* {{{ proto void CachingIterator::offsetUnset(mixed index) U
Unset given index in cache */
SPL_METHOD(CachingIterator, offsetUnset)
{
}
/* }}} */
-/* {{{ proto bool CachingIterator::offsetExists(mixed index)
+/* {{{ proto bool CachingIterator::offsetExists(mixed index) U
Return whether the requested index exists */
SPL_METHOD(CachingIterator, offsetExists)
{
}
/* }}} */
-/* {{{ proto bool CachingIterator::getCache()
+/* {{{ proto bool CachingIterator::getCache() U
Return the cache */
SPL_METHOD(CachingIterator, getCache)
{
}
/* }}} */
-/* {{{ proto int CachingIterator::getFlags()
+/* {{{ proto int CachingIterator::getFlags() U
Return the internal flags */
SPL_METHOD(CachingIterator, getFlags)
{
}
/* }}} */
-/* {{{ proto void CachingIterator::setFlags(int flags)
+/* {{{ proto void CachingIterator::setFlags(int flags) U
Set the internal flags */
SPL_METHOD(CachingIterator, setFlags)
{
{NULL, NULL, NULL}
};
-/* {{{ proto void RecursiveCachingIterator::__construct(RecursiveIterator it [, flags = CIT_CALL_TOSTRING])
+/* {{{ proto void RecursiveCachingIterator::__construct(RecursiveIterator it [, flags = CIT_CALL_TOSTRING]) U
Create an iterator from a RecursiveIterator */
SPL_METHOD(RecursiveCachingIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveCachingIterator, spl_ce_RecursiveIterator, DIT_RecursiveCachingIterator);
} /* }}} */
-/* {{{ proto bool RecursiveCachingIterator::hasChildren()
+/* {{{ proto bool RecursiveCachingIterator::hasChildren() U
Check whether the current element of the inner iterator has children */
SPL_METHOD(RecursiveCachingIterator, hasChildren)
{
RETURN_BOOL(intern->u.caching.zchildren);
} /* }}} */
-/* {{{ proto RecursiveCachingIterator RecursiveCachingIterator::getChildren()
+/* {{{ proto RecursiveCachingIterator RecursiveCachingIterator::getChildren() U
Return the inner iterator's children as a RecursiveCachingIterator */
SPL_METHOD(RecursiveCachingIterator, getChildren)
{
{NULL, NULL, NULL}
};
-/* {{{ proto void IteratorIterator::__construct(Traversable it)
+/* {{{ proto void IteratorIterator::__construct(Traversable it) U
Create an iterator from anything that is traversable */
SPL_METHOD(IteratorIterator, __construct)
{
{NULL, NULL, NULL}
};
-/* {{{ proto void NoRewindIterator::__construct(Iterator it)
+/* {{{ proto void NoRewindIterator::__construct(Iterator it) U
Create an iterator from another iterator */
SPL_METHOD(NoRewindIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_NoRewindIterator, zend_ce_iterator, DIT_NoRewindIterator);
} /* }}} */
-/* {{{ proto void NoRewindIterator::rewind()
+/* {{{ proto void NoRewindIterator::rewind() U
Prevent a call to inner iterators rewind() */
SPL_METHOD(NoRewindIterator, rewind)
{
/* nothing to do */
} /* }}} */
-/* {{{ proto bool NoRewindIterator::valid()
+/* {{{ proto bool NoRewindIterator::valid() U
Return inner iterators valid() */
SPL_METHOD(NoRewindIterator, valid)
{
RETURN_BOOL(intern->inner.iterator->funcs->valid(intern->inner.iterator TSRMLS_CC) == SUCCESS);
} /* }}} */
-/* {{{ proto mixed NoRewindIterator::key()
+/* {{{ proto mixed NoRewindIterator::key() U
Return inner iterators key() */
SPL_METHOD(NoRewindIterator, key)
{
}
} /* }}} */
-/* {{{ proto mixed NoRewindIterator::current()
+/* {{{ proto mixed NoRewindIterator::current() U
Return inner iterators current() */
SPL_METHOD(NoRewindIterator, current)
{
RETURN_ZVAL(*data, 1, 0);
} /* }}} */
-/* {{{ proto void NoRewindIterator::next()
+/* {{{ proto void NoRewindIterator::next() U
Return inner iterators next() */
SPL_METHOD(NoRewindIterator, next)
{
{NULL, NULL, NULL}
};
-/* {{{ proto void InfiniteIterator::__construct(Iterator it)
+/* {{{ proto void InfiniteIterator::__construct(Iterator it) U
Create an iterator from another iterator */
SPL_METHOD(InfiniteIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_InfiniteIterator, zend_ce_iterator, DIT_InfiniteIterator);
} /* }}} */
-/* {{{ proto void InfiniteIterator::next()
+/* {{{ proto void InfiniteIterator::next() U
Prevent a call to inner iterators rewind() (internally the current data will be fetched if valid()) */
SPL_METHOD(InfiniteIterator, next)
{
{NULL, NULL, NULL}
};
-/* {{{ proto void EmptyIterator::rewind()
+/* {{{ proto void EmptyIterator::rewind() U
Does nothing */
SPL_METHOD(EmptyIterator, rewind)
{
} /* }}} */
-/* {{{ proto false EmptyIterator::valid()
+/* {{{ proto false EmptyIterator::valid() U
Return false */
SPL_METHOD(EmptyIterator, valid)
{
RETURN_FALSE;
} /* }}} */
-/* {{{ proto void EmptyIterator::key()
+/* {{{ proto void EmptyIterator::key() U
Throws exception BadMethodCallException */
SPL_METHOD(EmptyIterator, key)
{
zend_throw_exception(spl_ce_BadMethodCallException, "Accessing the key of an EmptyIterator", 0 TSRMLS_CC);
} /* }}} */
-/* {{{ proto void EmptyIterator::current()
+/* {{{ proto void EmptyIterator::current() U
Throws exception BadMethodCallException */
SPL_METHOD(EmptyIterator, current)
{
zend_throw_exception(spl_ce_BadMethodCallException, "Accessing the value of an EmptyIterator", 0 TSRMLS_CC);
} /* }}} */
-/* {{{ proto void EmptyIterator::next()
+/* {{{ proto void EmptyIterator::next() U
Does nothing */
SPL_METHOD(EmptyIterator, next)
{
spl_append_it_fetch(intern TSRMLS_CC);
} /* }}} */
-/* {{{ proto void AppendIterator::__construct()
+/* {{{ proto void AppendIterator::__construct() U
Create an AppendIterator */
SPL_METHOD(AppendIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_AppendIterator, zend_ce_iterator, DIT_AppendIterator);
} /* }}} */
-/* {{{ proto void AppendIterator::append(Iterator it)
+/* {{{ proto void AppendIterator::append(Iterator it) U
Append an iterator */
SPL_METHOD(AppendIterator, append)
{
}
} /* }}} */
-/* {{{ proto void AppendIterator::rewind()
+/* {{{ proto void AppendIterator::rewind() U
Rewind to the first iterator and rewind the first iterator, too */
SPL_METHOD(AppendIterator, rewind)
{
}
} /* }}} */
-/* {{{ proto bool AppendIterator::valid()
+/* {{{ proto bool AppendIterator::valid() U
Check if the current state is valid */
SPL_METHOD(AppendIterator, valid)
{
RETURN_BOOL(intern->current.data);
} /* }}} */
-/* {{{ proto void AppendIterator::next()
+/* {{{ proto void AppendIterator::next() U
Forward to next element */
SPL_METHOD(AppendIterator, next)
{
spl_append_it_next(intern TSRMLS_CC);
} /* }}} */
-/* {{{ proto int AppendIterator::getIteratorIndex()
+/* {{{ proto int AppendIterator::getIteratorIndex() U
Get index of iterator */
SPL_METHOD(AppendIterator, getIteratorIndex)
{
spl_array_iterator_key(intern->u.append.zarrayit, return_value TSRMLS_CC);
} /* }}} */
-/* {{{ proto ArrayIterator AppendIterator::getArrayIterator()
+/* {{{ proto ArrayIterator AppendIterator::getArrayIterator() U
Get access to inner ArrayIterator */
SPL_METHOD(AppendIterator, getArrayIterator)
{
}
/* }}} */
-/* {{{ proto array iterator_to_array(Traversable it [, bool use_keys = true])
+/* {{{ proto array iterator_to_array(Traversable it [, bool use_keys = true]) U
Copy the iterator into an array */
PHP_FUNCTION(iterator_to_array)
{
}
/* }}} */
-/* {{{ proto int iterator_count(Traversable it)
+/* {{{ proto int iterator_count(Traversable it) U
Count the elements in an iterator */
PHP_FUNCTION(iterator_count)
{
}
/* }}} */
-/* {{{ proto int iterator_apply(Traversable it, mixed function [, mixed params])
+/* {{{ proto int iterator_apply(Traversable it, mixed function [, mixed params]) U
Calls a function for every element in an iterator */
PHP_FUNCTION(iterator_apply)
{
projects / php / commitdiff