Package IO

This class provides you methods to upload easily files to the ftp.

this class encapsulate an inject query result

this class encapsulate a query result set usage is: <code> foreach ($my_query_result as $result) { // do something with the $result } </code>

implements some simple queries

implements the query var replacement method

This factory provides the <code>DBConnection</code> and the <code>SQLQuerier</code> for the right sgbd.

class DBFactory | This factory provides the <code>DBConnection</code> and the <code>SQLQuerier</code> for the right sgbd.

This factory provides the <code>DBConnection</code> and the <code>SQLQuerier</code> for the right sgbd.

This factory provides the <code>DBConnection</code> and the <code>SQLQuerier</code> for the right sgbd.

This class encapsulate a query result set

This class encapsulate a query result set

Implements the query var replacement method

This class encapsulate a query result set

Implements the query var replacement method

This class encapsulate a query result set

This class encapsulate a query result set

Implements the query var replacement method

This class encapsulate a query result set

Translates the generic query <code>$query</code> into the mysql specific dialect

Translates the generic query <code>$query</code> into the mysql specific dialect

This interface represents a data store. Its different implementations store data in different physical areas, you have to use it according to the data's life span and the efficiency you need.

This data store is not already available, the APC PHP extension must be enabled for you yo use it.

This factory returns you the data store that are the best for your requirements.

This data store is not very efficient but is the only one which has an infinite life span when APC is not available.

This is a very efficient data store, but its principal weakness is that it's life span is very short, in fact it's the page's execution.

This interface represents configuration data which are stored automatically by the config manager. The storage mode is very powerful, it uses a two-level cache and the database.

This is a default and minimal implementation of the ConfigData interface.

This class manages config loading and saving. It makes a two-level lazy loading: <ul> <li>A top-level cache which avoids loading a data if it has already been done since the beginning of the current page generation. This cache has a short life span: it's flushed as of the PHP interpreter reaches the end of the page generation.</li> <li>A filesystem or shared RAM cache to avoid querying the database many times to obtain the same value.

This exception is raised when a configuration entry is load whereas it doesn't exists in the database.

This exception is raised when a not existing property is asked in a ConfigData object.

This interface represents data which are stored automatically by the cache manager.

This exception is raised when you are asking a cache entry that doesn't exist.

This class manages cache. It makes a two-level lazy loading: <ul> <li>A top-level cache which avoids loading a data if it has already been done since the beginning of the current page generation. This cache has a short life span: it's flushed as of the PHP interpreter reaches the end of the page generation.</li> <li>A filesystem or shared RAM (via APC) cache to avoid querying the database every time to obtain the same value.

This class represents a PHPBoost template. Templates are used to generate text which have a common structure. You just have to write your text with tags at the place you want to insert values and assign values in the objet, when you will display them, the tags will be replaced by the corresponding value.

This class is a default implementation of the Template interface using a TemplateLoader, a TemplateData and a TemplateParser.

This class allows you to handle a template file.

This class enables you to handle a template whose input is not a file but directly a string.

This interfaces represents a class that is able to parse a template source and transform it to a syntax that the PHP engine is able to run.

This is an abstract implementation of the {@link TemplateParser} interface.

template = (variableExpression | expression | condition | loop | include | text)* variableExpression = "{", variable, "}" expression = "${", expressionContent, "}" condition = "# IF ", "NOT "?, expression, "#", template, ("# ELSE #, template)?, "# ENDIF #" loop = "# START ", expression, " #", template, "# END (?:name)? #" include = "# INCLUDE ", name, " #" text = .+ expressionContent = array | function | variable | constant function = "\(\w+::\)?\w+\(", parameters, "\)" parameters = expressionContent | (expressionContent, (",", expressionContent)+) variable = simpleVar | loopVar constant = "'.+'" | [0-9]+ | array array = "array(", arrayContent, ")" arrayContent = arrayElement | (arrayElement, (",", arrayElement)+) arrayElement = expressionContent | ("'\w+'\s*=>\s*", expressionContent) simpleVar = "\w+" loopVar = "(\w+\.)+\w+"

Represents a template renderer as its names shows. Its able to get the result of the template interpration from a TemplateLoader which gives it the template source and a TemplateData which contains the data to assign in the template.

This template renderer is able to deal with both loader which cache and don't cache.

This class is responsible to load a template and transform it in the PHPBoost parsed template syntax.

This loader is to use when you load a template whose source is directly a PHP string and not a file. It supports caching and saves cache files in the /cache/tpl directory, using a md5 hash to distinguish eache string input.

This loader is the most used. It takes a file identifier as input. This identifier corresponds to a file that can be different from the user's theme. In fact, when it loads a template, its looks for it at several places. For a module template, it can be the default one which is in the /module/templates directory, but if the file is specialized by the theme, it loads it from the theme directory. All that is explained in the {@link FileTemplate} class description.

This exception is thrown when the template cannot been loaded.

This loader is a very simple one. Its input is a string containing the template source.

This exception is thrown when the template cannot been loaded.

This interface describes data which are assigned to a template. There are two types of data: <ul> <li>Variables: there are string that are directly displayed</li> <li>Templates: you can embed a template in another one. When a subtemplate is displayed, it's parsed using its own data and the result is inserted where the subtemplate is embedded.</li> </ul> A template contains global variables which are available in the whole template and local variable which are only defined into a loop. To define a loop, you just have to use assign_block_vars with the same loop identifier for each loop iteration. Loops can be nested and embed both variables and subtemplates.

This class is a default implementation of the {@link TemplateData} interface.

This class represents a text file which can be read and written.

This class represents any file system element.

This class allows you to handle very easily a folder on the server.

This class allows you to obtain informations on an image.

This class allows you to resize images easily.

Manages cookies via the HTTP protocol

Provides access to the HTTP request parameters

Manages response via the HTTP protocol

Manages the HTTP file upload

Represents a HTTP uploaded file

Represents a HTTP uploaded file

This class allows you to send mails without having to deal with the mail headers and parameters.

This class provides you utilities for emails.