Docs For Class File

File_Archive_Writer appender(

$URL, [
$unique = false], [
$type = null], [
$stat = array()], File_Archive_Reader
$source)

Create a writer that allows appending new files to an existing archive This function actes as appendToSource with source being the system files $URL can't be null here

Return: a writer that you can use to append files to the reader

Parameters:

File_Archive_Reader	`$source`	—	A reader where some files will be appended
	`$URL`	—
	`$unique`	—
	`$type`	—
	`$stat`	—

[ Top ]

File_Archive_Writer appenderFromSource(

&$source, [string
$URL = null], [bool
$unique = false], [string
$type = null], [array
$stat = array()], File_Archive_Reader
$source)

Create a writer that can be used to append files to an archive inside a source

If the archive can't be found in the source, it will be created If source is set to null, File_Archive::toFiles will be assumed If type is set to null, the type of the archive will be determined looking at the extension in the URL stat is the array of stat (returned by stat() PHP function of Reader getStat()) to use if the archive must be created

This function allows to create or append data to nested archives. Only one archive will be created and if your creation requires creating several nested archives, a PEAR error will be returned

After this call, $source will be closed and should not be used until the returned writer is closed.

Return: a writer that you can use to append files to the reader

Parameters:

File_Archive_Reader	`$source`	—	A reader where some files will be appended
string	`$URL`	—	URL to reach the archive in the source. if $URL is null, a writer to append files to the $source reader will be returned
bool	`$unique`	—	If true, the duplicate files will be deleted on close Default is false (and setting it to true may have some performance consequences)
string	`$type`	—	Extension of the archive (or null to use the one in the URL)
array	`$stat`	—	Used only if archive is created, array of stat as returned by PHP stat function or Reader getStat function: stats of the archive) Time (index 9) will be overwritten to current time
	`&$source`	—

[ Top ]

null extract(

&$source, 
&$dest, [bool
$autoClose = true], [int
$bufferSize = 8192], File_Archive_Reader
$source, File_Archive_Writer
$dest)

File_Archive::extract($source, $dest) is equivalent to $source->extract($dest)

If $source is a PEAR error, the error will be returned It is thus easier to use this function than $source->extract, since it reduces the number of error checking and doesn't force you to define a variable $source

Return: or a PEAR error if an error occured

Parameters:

File_Archive_Reader	`$source`	—	The source that will be read
File_Archive_Writer	`$dest`	—	Where to copy $source files
bool	`$autoClose`	—	if true (default), $dest will be closed after the extraction
int	`$bufferSize`	—	Size of the buffer to use to move data from the reader to the buffer You shouldn't need to change that
	`&$source`	—
	`&$dest`	—

[ Top ]

void filter(
File_Archive_Predicate
$predicate, File_Archive_Reader
$source)

Removes from a source the files that do not follow a given predicat

See: File_Archive_Reader_Filter

Parameters:

File_Archive_Predicate	`$predicate`	—	Only the files for which $predicate->isTrue() will be kept
File_Archive_Reader	`$source`	—	Source that will be filtered

[ Top ]

bool isKnownExtension(
string
$extension)

Check if a file with a specific extension can be read as an archive with File_Archive::read* This function is case sensitive.

Return: whether this file can be understood reading its extension Currently, supported extensions are tar, zip, gz, tgz, tbz, bz2 and bzip2

Parameters:

string $extension — the checked extension

[ Top ]

void predAnd(
File_Archive_Predicate
0)

Predicate that evaluates to the logical AND of the parameters You can add other predicates thanks to the File_Archive_Predicate_And::addPredicate() function

See: File_Archive_Predicate_And

Parameters:

File_Archive_Predicate 0 — (any number of them)

[ Top ]

void predCustom(
string
$expression)

Custom predicate built by supplying a string expression

Here are different ways to create a predicate that keeps only files with names shorter than 100 chars <sample> File_Archive::predCustom("return strlen($name)<100;") File_Archive::predCustom("strlen($name)<100;") File_Archive::predCustom("strlen($name)<100") File_Archive::predCustom("strlen($source->getFilename())<100") </sample>

See: File_Archive_Predicate_Custom

Parameters:

string $expression — String containing an expression that evaluates to a boolean. If the expression doesn't contain a return statement, it will be added at the begining of the expression A ';' will be added at the end of the expression so that you don't have to write it. You may use the $name variable to refer to the current filename (with path...), $time for the modification time (unix timestamp), $size for the size of the file in bytes, $mime for the MIME type of the file

[ Top ]

void predEreg(
string
$ereg)

Evaluates to true iif the name of the file follow a given regular expression

See: File_Archive_Predicate_Ereg, ereg()

Parameters:

string $ereg — regular expression that the filename must follow

[ Top ]

void predEregi(
string
$ereg)

Evaluates to true iif the name of the file follow a given regular expression (case insensitive version)

See: File_Archive_Predicate_Eregi, eregi

Parameters:

string $ereg — regular expression that the filename must follow

[ Top ]

void predExtension(
array
$list)

Evaluates to true iif the extension of the file is in a given list

See: File_Archive_Predicate_Extension

Parameters:

array $list — or string $list List or comma separated string of possible extension of the files

[ Top ]

void predFalse(
)

Predicate that always evaluate to false

See: File_Archive_Predicate_False

[ Top ]

void predMaxDepth(
int
$depth)

Evaluates to true iif the file has less that a given number of directories in its path

See: File_Archive_Predicate_MaxDepth

Parameters:

int $depth — Maximal number of directories in path of the files

[ Top ]

void predMIME(
array
$list)

Evaluates to true iif the MIME type of the file is in a given list

See: File_Archive_Predicate_MIME, MIME_Type::isWildcard()

Parameters:

array $list — or string $list List or comma separated string of possible MIME types of the files. You may enter wildcards like "image/*" to select all the MIME in class image

[ Top ]

void predMinSize(
int
$size)

Evaluates to true iif the file is larger than a given size

See: File_Archive_Predicate_MinSize

Parameters:

int $size — the minimal size of the files (in Bytes)

[ Top ]

void predMinTime(
int
$time)

Evaluates to true iif the file has been modified after a given time

See: File_Archive_Predicate_MinTime

Parameters:

int $time — Unix timestamp of the minimal modification time of the files

[ Top ]

void predNot(
File_Archive_Predicate
$pred)

Negate a predicate

See: File_Archive_Predicate_Not

Parameters:

File_Archive_Predicate $pred — Predicate to negate

[ Top ]

void predOr(
File_Archive_Predicate
0)

Predicate that evaluates to the logical OR of the parameters You can add other predicates thanks to the File_Archive_Predicate_Or::addPredicate() function

See: File_Archive_Predicate_Or

Parameters:

File_Archive_Predicate 0 — (any number of them)

[ Top ]

void predTrue(
)

Predicate that always evaluate to true

See: File_Archive_Predicate_True

[ Top ]

void read(

$URL, [
$symbolic = null], [
$uncompression = 0], [
$directoryDepth = -1])

Parameters:

	`$URL`	—
	`$symbolic`	—
	`$uncompression`	—
	`$directoryDepth`	—

[ Top ]

A readArchive(
string
$extension, 
&$source, [bool
$sourceOpened = false], File_Archive_Reader
$source)

Create a reader that will read the single file source $source as a specific archive

Return: File_Archive_Reader that uncompresses the archive contained in $source interpreting it as a $extension archive If $extension is not handled return false

Parameters:

string	`$extension`	—	determines the kind of archive $source contains $extension is case sensitive
File_Archive_Reader	`$source`	—	stores the archive
bool	`$sourceOpened`	—	specifies if the archive is already opened if false, next will be called on source Closing the returned archive will close $source iif $sourceOpened is true
	`&$source`	—

[ Top ]

void readConcat(

&$source, string
$filename, [array
$stat = array()], [string
$mime = null], File_Archive_Reader
$source)

Make the files of a source appear as one large file whose content is the concatenation of the content of all the files

See: File_Archive_Reader_Concat

Parameters:

File_Archive_Reader	`$source`	—	The source whose files must be concatened
string	`$filename`	—	name of the only file of the created reader
array	`$stat`	—	statistics of the file. Index 7 (size) will be overwritten to match the total size of the files
string	`$mime`	—	mime type of the file. Default will determine the mime type thanks to the extension of $filename
	`&$source`	—

[ Top ]

void readMemory(
string
$memory, string
$filename, [array
$stat = array()], [string
$mime = null])

Contains only one file with data read from a memory buffer

See: File_Archive_Reader_Memory

Parameters:

string	`$memory`	—	content of the file
string	`$filename`	—	public name of the file
array	`$stat`	—	statistics of the file. Index 7 (size) will be overwritten to match the size of $memory
string	`$mime`	—	mime type of the file. Default will determine the mime type thanks to the extension of $filename

[ Top ]

void readMulti(
[array
$sources = array()])

Contains several other sources. Take care the sources don't have several files with the same filename. The sources are given as a parameter, or can be added thanks to the reader addSource method

See: File_Archive_Reader_Multi, File_Archive::read()

Parameters:

array $sources — Array of strings or readers that will be added to the multi reader. If the parameter is a string, a reader will be built thanks to the read function

[ Top ]

void readSource(

&$source, 
$URL, [
$symbolic = null], [
$uncompression = 0], [
$directoryDepth = -1])

Create a reader to read the URL $URL.

If the URL is a directory, it will recursively read that directory. If $uncompressionLevel is not null, the archives (files with extension tar, zip, gz or tgz) will be considered as directories (up to a depth of $uncompressionLevel if $uncompressionLevel > 0). The reader will only read files with a directory depth of $directoryDepth. It reader will replace the given URL ($URL) with $symbolic in the public filenames The default symbolic name is the last filename in the URL (or '' for directories)

Examples: Considere the following file system

 a.txt
 b.tar (archive that contains the following files)
     c.txt
     d.tgz (archive that contains the following files)
         e.txt
         dir1/
             f.txt
 dir2/
     g.txt
     dir3/
         h.tar (archive that contains the following files)
             i.txt

read('.') will return a reader that gives access to following files (recursively read current dir):

 a.txt
 b.tar
 dir2/g.txt
 dir2/dir3/h.tar

read('.', 'myBaseDir') will return the following reader:

 myBaseDir/a.txt
 myBaseDir/b.tar
 myBaseDir/dir2/g.txt
 myBaseDir/dir2/dir3/h.tar

read('.', '', -1) will return the following reader (uncompress everything)

 a.txt
 b.tar/c.txt
 b.tar/d.tgz/e.txt
 b.tar/d.tgz/dir1/f.txt
 dir2/g.txt
 dir2/dir3/h.tar/i.txt

read('.', '', 1) will uncompress only one level (so d.tgz will not be uncompressed):

 a.txt
 b.tar/c.txt
 b.tar/d.tgz
 dir2/g.txt
 dir2/dir3/h.tar/i.txt

read('.', '', 0, 0) will not recurse into subdirectories

 a.txt
 b.tar

read('.', '', 0, 1) will recurse only one level in subdirectories

 a.txt
 b.tar
 dir2/g.txt

read('.', '', -1, 2) will uncompress everything and recurse in only 2 levels in subdirectories or archives

 a.txt
 b.tar/c.txt
 b.tar/d.tgz/e.txt
 dir2/g.txt

The recursion level is determined by the real path, not the symbolic one. So read('.', 'myBaseDir', -1, 2) will result to the same files:

 myBaseDir/a.txt
 myBaseDir/b.tar/c.txt
 myBaseDir/b.tar/d.tgz/e.txt (accepted because the real depth is 2)
 myBaseDir/dir2/g.txt

Use readSource to do the same thing, reading from a specified reader instead of reading from the system files

To read a single file, you can do read('a.txt', 'public_name.txt') If no public name is provided, the default one is the name of the file read('dir2/g.txt') contains the single file named 'g.txt' read('b.tar/c.txt') contains the single file named 'c.txt'

Note: This function uncompress files reading their extension The compressed files must have a tar, zip, gz or tgz extension Since it is impossible for some URLs to use is_dir or is_file, this function may not work with URLs containing folders which name ends with such an extension

Parameters:

	`&$source`	—
	`$URL`	—
	`$symbolic`	—
	`$uncompression`	—
	`$directoryDepth`	—

[ Top ]

void remove(
$URL
&$pred, 
$URL)

Remove the files that follow a given predicate from the archive specified in $URL

Parameters:

$URL	`&$pred`	—	URL of the archive where some files must be removed
	`$URL`	—

[ Top ]

void removeDuplicates(

$URL)

Remove duplicates from the archive specified in the URL

Parameters:

$URL —

[ Top ]

void removeDuplicatesFromSource(
File_Archive_Reader
&$source, [
$URL = null])

Remove duplicates from a source, keeping the most recent one (or the one that has highest pos in the archive if the files have same date or no date specified)

Parameters:

File_Archive_Reader	`&$source`	—	a reader that may contain duplicates
	`$URL`	—

[ Top ]

void removeFromSource(

&$pred, 
&$source, [
$URL = null], File_Archive_Predicate
$pred, File_Archive_Reader
$source)

Remove the files that follow a given predicate from the source If URL is null, the files will be removed from the source directly Else, URL must link to a source from which the files will be removed

Parameters:

File_Archive_Predicate	`$pred`	—	The files that follow the predicate (for which $pred->isTrue($source) is true) will be erased
File_Archive_Reader	`$source`	—	A reader that contains the files to remove
	`&$pred`	—
	`&$source`	—
	`$URL`	—

[ Top ]

void toArchive(
string
$filename, 
&$innerWriter, [string
$type = null], [array
$stat = array()], [bool
$autoClose = true], File_Archive_Writer
$innerWriter)

Compress the data to a tar, gz, tar/gz or zip format

Parameters:

string	`$filename`	—	name of the archive file
File_Archive_Writer	`$innerWriter`	—	writer where the archive will be written
string	`$type`	—	can be one of tgz, tbz, tar, zip, gz, gzip, bz2, bzip2 (default is the extension of $filename) or any composition of them (for example tar.gz or tar.bz2). The case of this parameter is not important.
array	`$stat`	—	Statistics of the archive (see stat function)
bool	`$autoClose`	—	If set to true, $innerWriter will be closed when the returned archive is close. Default value is true.
	`&$innerWriter`	—

[ Top ]

void toFiles(
[string
$baseDir = ""])

Write the files on the hard drive

See: File_Archive_Writer_Files

Parameters:

string $baseDir — if specified, the files will be created in that directory. If they don't exist, the directories will automatically be created

[ Top ]

void toMail(

$to, array
$headers, string
$message, [Mail
$mail = null])

Send the files as a mail attachment

See: File_Archive_Writer_Mail

Parameters:

Mail	`$mail`	—	Object used to send mail (see Mail::factory)
array	`$headers`	—	or String $to An array or a string with comma separated recipients
string	`$message`	—	Text body of the mail
	`$to`	—

[ Top ]

void toMemory(
out
$data)

Send the content of the files to a memory buffer

toMemory returns a writer where the data will be written. In this case, the data is accessible using the getData member

toVariable returns a writer that will write into the given variable

See: File_Archive_Writer_Memory

Parameters:

out $data — if specified, the data will be written to this buffer Else, you can retrieve the buffer with the File_Archive_Writer_Memory::getData() function

[ Top ]

void toMulti(

&$a, 
&$b, File_Archive_Writer
$a,)

Duplicate the writing operation on two writers

See: File_Archive_Writer_Multi

Parameters:

File_Archive_Writer	`$a,`	—	$b writers where data will be duplicated
	`&$a`	—
	`&$b`	—

[ Top ]

void toOutput(
[bool
$sendHeaders = true])

Send the content of the files to the standard output (so to the client for a website)

See: File_Archive_Writer_Output

Parameters:

bool $sendHeaders — If true some headers will be sent to force the download of the file. Default value is true

[ Top ]

void toVariable(

&$v)

Parameters:

&$v —

[ Top ]

Class: File_Archive

Class Overview

Methods

Inherited Variables

Inherited Methods

Class Details

Method Detail

appender [line 980]

Parameters:

appenderFromSource [line 926]

Parameters:

extract [line 889]

Parameters:

filter [line 517]

Parameters:

isKnownExtension [line 373]

Parameters:

predAnd [line 550]

Parameters:

predCustom [line 695]

Parameters:

predEreg [line 656]

Parameters:

predEregi [line 668]

Parameters:

predExtension [line 631]

Parameters:

predFalse [line 537]

predMaxDepth [line 619]

Parameters:

predMIME [line 644]

Parameters:

predMinSize [line 595]

Parameters:

predMinTime [line 607]

Parameters:

predNot [line 584]

Parameters:

predOr [line 568]

Parameters:

predTrue [line 527]

read [line 356]

Parameters:

readArchive [line 401]

Parameters:

readConcat [line 503]

Parameters:

readMemory [line 454]

Parameters:

readMulti [line 470]

Parameters:

readSource [line 159]

Parameters:

remove [line 1022]

Parameters:

removeDuplicates [line 1060]

Parameters:

removeDuplicatesFromSource [line 1034]

Parameters:

removeFromSource [line 995]

Parameters:

toArchive [line 799]

Parameters:

toFiles [line 725]

Parameters:

toMail [line 712]

Parameters:

toMemory [line 744]

Parameters:

toMulti [line 760]

Parameters:

toOutput [line 780]

Parameters:

toVariable [line 749]

Parameters: