Constructor.

• return: FastTemplate object

• template $pathToTemplates: root.

assign template variables with the same names from array by specfied keys

NOTE: template variables will be in upper case

Cleans the module of any data, except for the ROOT directory.

This is equivalent to:

$tpl->clear_define();
$tpl->clear_href();
$tpl->clear_tpl();
$tpl->clear_parse();

Clears the internal list that stores data passed to:

$tpl->define();

Note: The hash that holds the loaded templates is not touched with this method. ( See: clear_tpl() ) Accepts a single file handle, an array of file handles, or nothing as arguments. If no argument is given, it clears ALL file handles.

$tpl->define( array( MAIN => "main.html",
BODY => "body.html", FOOT => "foot.html"  ));
(some code here)
$tpl->clear_define("MAIN");

Removes a given reference from the list of refs that is built using:

$tpl->assign(KEY = val);

If it's called with no arguments, it removes all references from the array.

$tpl->assign(    array(    MOVIE  =>  "The Avengers", RATE   =>  "BadMovie"    ));
$tpl->clear_href("MOVIE"); 

Clears the internal array that stores the contents of the templates (if they have been loaded)

If you are having problems with template changes not being reflected, try adding this method to your script.

$tpl->define(MAIN,"main.html" );
 ( assign(), parse() etc etc...)
$tpl->clear_tpl(MAIN);    

You can define dynamic content within a static template.

Here's an example of define_dynamic();

 $tpl = new FastTemplate("./templates");
 $tpl->define(    array( main  =>  "main.html",table =>  "dynamic.html" ));
 $tpl->define_dynamic( "row" , "table" );

 <!-- NAME: dynamic.html -->
  <table>
  <!-- BEGIN DYNAMIC BLOCK: row -->
  <tr>
   <td>{NUMBER}</td>
   <td>{BIG_NUMBER}</td>
  </tr>
  <!-- END DYNAMIC BLOCK: row -->
 </table>
 <!-- END: dynamic.html -->

The syntax of your BEGIN and END lines needs to be VERY exact. It is case sensitive. The code block begins on a new line all by itself. There cannot be ANY OTHER TEXT on the line with the BEGIN or END statement. (although you can have any amount of whitespace before or after) It must be in the format shown:
<!-- BEGIN DYNAMIC BLOCK: handle_name -->
The line must be exact, right down to the spacing of the characters. The same is true for your END line. The BEGIN and END lines cannot span multiple lines. Now when you call the parse() method, FastTemplate will automatically spot the dynamic block, strip it out, and use it exactly as if you had defined it as a stand-alone template. No additional work is required on your part to make it work - just define it, and FastTemplate will do the rest. Included with this archive should have been a file named define_dynamic.phtml which shows a working example of a dynamic block.
There are a few rules when using dynamic blocks - dynamic blocks should not be nested inside other dynamic blocks - strange things WILL occur. You -can- have more than one nested block of code in a page, but of course, no two blocks can share the same defined handle. The error checking for define_dynamic() is miniscule at best. If you define a dynamic block and FastTemplate fails to find it, no errors will be generated, just really weird output. (FastTemplate will not append the dynamic data to the retured output) Since the BEGIN and END lines are stripped out of the parsed results, if you ever see your BEGIN or END line in the parsed output, that means that FastTemplate failed to find that dynamic block.

• input $Macro: Macro Name
• input $ParentName: Parent Name

Put an error message and stop (if requested)

• string $errorMsg
• bool $die

Output the HTML-Code to a file.

The method FastWrite() write the contents of the named variable into a file.

$tpl->FastWrite("output.html"); // continuing from the last example, would
$tpl->FastWrite("MAIN","output.html"); 

This method is provided for convenience. If you need to print somewhere else (a socket, file handle) you would want to fetch() a reference to the data first:

 $data = $tpl->fetch("MAIN");
 fwrite($fd, $data);     

• input $template: template
• outfile $outputfile

Return the value of an assigned variable.

This method will return the value of a variable that has been set via assign(). This allows you to easily pass variables around within functions by using the FastTemplate class to handle ``globalization'' of the variables.

For example:

 $tpl->assign(  array(  TITLE    =>    $title,
 BGCOLOR  =>    $bgColor, TEXT     =>    $textColor ));
 $bgColor = $tpl->get_assigned(BGCOLOR);

Grabs a template from the root dir and

reads it into a (potentially REALLY) big string

• $template $template: template name

Pattern Assign

Pattern Assign - when variables or constants are the same as the template keys, these functions may be used as they are. Using these functions, can help you reduce the number of the assign functions in the php files

Useful for language files where all variables or constants have the same prefix.i.e. $LANG_SOME_VAR or LANG_SOME_CONST
The $pattern is LANG in this case.

Turns off warning messages about unresolved template variables.

A call to no_strict() is required to replace unknown variables with an empty string. By default, all instances of FastTemplate behave as is strict() was called. Also, no_strict() must be set for each instance of FastTemplate.

 $tpl = new FastTemplate("/path/to/templates");
 $tpl->no_strict();

Parse param string and replace simple variable

• string $string

Sets template root All templates will be loaded from this "root" directory Can be changed in mid-process by re-calling with a new value.

• $root $root: path to templates dir

Prints the warnings for unresolved variable references

in template files. Used if STRICT is true

• $Line $Line: string for variable references checking

Try to use cached files.

• string $fname: forldername