PHP Classes

File: htdocs/class/smarty/xoops_plugins/compiler.includeq.php

Recommend this page to a friend!
  Classes of Michael Beck  >  Xoops 2.5  >  htdocs/class/smarty/xoops_plugins/compiler.includeq.php  >  Download  
File: htdocs/class/smarty/xoops_plugins/compiler.includeq.php
Role: Example script
Content type: text/plain
Description: Example script
Class: Xoops 2.5
Modular content management publication system
Author: By
Last change:
Date: 3 years ago
Size: 3,440 bytes
 

 

Contents

Class file image Download
<?php
/**
 * includeq Smarty compiler plug-in
 *
 * See the enclosed file LICENSE for licensing information.
 * If you did not receive this file, get it at http://www.gnu.org/licenses/gpl-2.0.html
 *
 * @copyright (c) 2000-2016 XOOPS Project (www.xoops.org)
 * @license GNU GPL 2 (http://www.gnu.org/licenses/gpl-2.0.html)
 * @author Skalpa Keo <skalpa@xoops.org>
 * @package xos_opal
 * @subpackage xos_opal_Smarty
 * @since 2.0.14
 */

/**
 * Quick include template plug-in
 *
 * Like {@link smarty_compiler_foreachq() foreachq}, this plug-in has been written to provide
 * a faster version of an already existing Smarty function. <var>includeq</var> can be used
 * as a replacement for the Smarty
 * {@link http://smarty.php.net/manual/en/language.function.include.php include} function as long
 * as you are aware of the differences between them.
 *
 * Normally, when you include a template, Smarty does the following:
 * - Backup all your template variables in an array
 * - Include the template you specified
 * - Restore the template variables from the previously created backup array
 *
 * The advantage of this method is that it makes the main template variables <i>safe</i>: if your
 * main template uses a variable called <var>$stuff</var> and the included template modifies it
 * value, the main template will recover the original value automatically.
 *
 * While this can be useful in some cases (for example, when you include templates you have absolutely
 * no control over), some may consider this a limitation and it has the disadvantage of slowing down
 * the inclusion mechanism a lot.
 *
 * <var>includeq</var> fixes that: the code it generates doesn't contain the variables backup/recovery
 * mechanism and thus makes templates inclusion faster. Note that however, this new behavior may
 * create problems in some cases (but you can prevent them most of the times, for example by always
 * using a <var>tmp_</var> prefix for the variables you create in included templates looping sections).
 * @param $tag_args
 * @param $comp
 * @return string
 */
function smarty_compiler_includeq($tag_args, &$comp)
{
   
$attrs = $comp->_parse_attrs($tag_args);
   
$arg_list = array();

    if (empty(
$attrs['file'])) {
       
$comp->_syntax_error("missing 'file' attribute in includeq tag", E_USER_ERROR, __FILE__, __LINE__);
    }

    foreach (
$attrs as $arg_name => $arg_value) {
        if (
$arg_name === 'file') {
           
$include_file = $arg_value;
            continue;
        } elseif (
$arg_name === 'assign') {
           
$assign_var = $arg_value;
            continue;
        }
        if (
is_bool($arg_value)) {
           
$arg_value = $arg_value ? 'true' : 'false';
        }
       
$arg_list[] = "'$arg_name' => $arg_value";
    }

   
$output = '';

    if (isset(
$assign_var)) {
       
$output .= "ob_start();\n";
    }

   
//$output .= "\$_smarty_tpl_vars = \$this->_tpl_vars;\n";
   
$_params = "array('smarty_include_tpl_file' => " . $include_file . ", 'smarty_include_vars' => array(" . implode(',', (array)$arg_list) . '))';
   
$output .= "\$this->_smarty_include($_params);\n";
   
//"\$this->_tpl_vars = \$_smarty_tpl_vars;\n" .
    //"unset(\$_smarty_tpl_vars);\n";

   
if (isset($assign_var)) {
       
$output .= "\$this->assign(" . $assign_var . ", ob_get_contents()); ob_end_clean();\n";
    }

   
//$output .= '';
   
return $output;
}


For more information send a message to info at phpclasses dot org.