PHP encapsulated smartBC class-PHP Tutorial-php.cn

This article mainly introduces the PHP-encapsulated smartBC class, which achieves effective compatibility and expansion for Smarty2 through custom classes. Friends in need can refer to
. The details are as follows:
<?php
/**
 * Project:   Smarty: the PHP compiling template engine
 * File:    SmartyBC.class.php
 * SVN:     $Id: $
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 * For questions, help, comments, discussion, etc., please join the
 * Smarty mailing list. Send a blank e-mail to
 * smarty-discussion-subscribe@googlegroups.com
 *
 * @link   http://www.smarty.net/
 * @copyright 2008 New Digital Group, Inc.
 * @author  Monte Ohrt <monte at ohrt dot com>
 * @author  Uwe Tews
 * @author  Rodney Rehm
 * @package  Smarty
 */
/**
 * @ignore
 */
require_once(dirname(__FILE__) . &#39;/Smarty.class.php&#39;);
/**
 * Smarty Backward Compatability Wrapper Class
 *
 * @package Smarty
 */
class SmartyBC extends Smarty
{
  /**
   * Smarty 2 BC
   *
   * @var string
   */
  public $_version = self::SMARTY_VERSION;
  /**
   * Initialize new SmartyBC object
   *
   * @param array $options options to set during initialization, e.g. array( &#39;forceCompile&#39; => false )
   */
  public function __construct(array $options = array())
  {
    parent::__construct($options);
    // register {php} tag
    $this->registerPlugin(&#39;block&#39;, &#39;php&#39;, &#39;smarty_php_tag&#39;);
  }
  /**
   * wrapper for assign_by_ref
   *
   * @param string $tpl_var the template variable name
   * @param mixed &$value the referenced value to assign
   */
  public function assign_by_ref($tpl_var, &$value)
  {
    $this->assignByRef($tpl_var, $value);
  }
  /**
   * wrapper for append_by_ref
   *
   * @param string $tpl_var the template variable name
   * @param mixed  &$value the referenced value to append
   * @param boolean $merge  flag if array elements shall be merged
   */
  public function append_by_ref($tpl_var, &$value, $merge = false)
  {
    $this->appendByRef($tpl_var, $value, $merge);
  }
  /**
   * clear the given assigned template variable.
   *
   * @param string $tpl_var the template variable to clear
   */
  public function clear_assign($tpl_var)
  {
    $this->clearAssign($tpl_var);
  }
  /**
   * Registers custom function to be used in templates
   *
   * @param string $function   the name of the template function
   * @param string $function_impl the name of the PHP function to register
   * @param bool  $cacheable
   * @param mixed $cache_attrs
   */
  public function register_function($function, $function_impl, $cacheable = true, $cache_attrs = null)
  {
    $this->registerPlugin(&#39;function&#39;, $function, $function_impl, $cacheable, $cache_attrs);
  }
  /**
   * Unregisters custom function
   *
   * @param string $function name of template function
   */
  public function unregister_function($function)
  {
    $this->unregisterPlugin(&#39;function&#39;, $function);
  }
  /**
   * Registers object to be used in templates
   *
   * @param string $object   name of template object
   * @param object $object_impl the referenced PHP object to register
   * @param array  $allowed   list of allowed methods (empty = all)
   * @param boolean $smarty_args smarty argument format, else traditional
   * @param array  $block_methods list of methods that are block format
   *
   * @throws SmartyException
   * @internal param array $block_functs list of methods that are block format
   */
  public function register_object($object, $object_impl, $allowed = array(), $smarty_args = true, $block_methods = array())
  {
    settype($allowed, &#39;array&#39;);
    settype($smarty_args, &#39;boolean&#39;);
    $this->registerObject($object, $object_impl, $allowed, $smarty_args, $block_methods);
  }
  /**
   * Unregisters object
   *
   * @param string $object name of template object
   */
  public function unregister_object($object)
  {
    $this->unregisterObject($object);
  }
  /**
   * Registers block function to be used in templates
   *
   * @param string $block   name of template block
   * @param string $block_impl PHP function to register
   * @param bool  $cacheable
   * @param mixed $cache_attrs
   */
  public function register_block($block, $block_impl, $cacheable = true, $cache_attrs = null)
  {
    $this->registerPlugin(&#39;block&#39;, $block, $block_impl, $cacheable, $cache_attrs);
  }
  /**
   * Unregisters block function
   *
   * @param string $block name of template function
   */
  public function unregister_block($block)
  {
    $this->unregisterPlugin(&#39;block&#39;, $block);
  }
  /**
   * Registers compiler function
   *
   * @param string $function   name of template function
   * @param string $function_impl name of PHP function to register
   * @param bool  $cacheable
   */
  public function register_compiler_function($function, $function_impl, $cacheable = true)
  {
    $this->registerPlugin(&#39;compiler&#39;, $function, $function_impl, $cacheable);
  }
  /**
   * Unregisters compiler function
   *
   * @param string $function name of template function
   */
  public function unregister_compiler_function($function)
  {
    $this->unregisterPlugin(&#39;compiler&#39;, $function);
  }
  /**
   * Registers modifier to be used in templates
   *
   * @param string $modifier   name of template modifier
   * @param string $modifier_impl name of PHP function to register
   */
  public function register_modifier($modifier, $modifier_impl)
  {
    $this->registerPlugin(&#39;modifier&#39;, $modifier, $modifier_impl);
  }
  /**
   * Unregisters modifier
   *
   * @param string $modifier name of template modifier
   */
  public function unregister_modifier($modifier)
  {
    $this->unregisterPlugin(&#39;modifier&#39;, $modifier);
  }
  /**
   * Registers a resource to fetch a template
   *
   * @param string $type   name of resource
   * @param array $functions array of functions to handle resource
   */
  public function register_resource($type, $functions)
  {
    $this->registerResource($type, $functions);
  }
  /**
   * Unregisters a resource
   *
   * @param string $type name of resource
   */
  public function unregister_resource($type)
  {
    $this->unregisterResource($type);
  }
  /**
   * Registers a prefilter function to apply
   * to a template before compiling
   *
   * @param callable $function
   */
  public function register_prefilter($function)
  {
    $this->registerFilter(&#39;pre&#39;, $function);
  }
  /**
   * Unregisters a prefilter function
   *
   * @param callable $function
   */
  public function unregister_prefilter($function)
  {
    $this->unregisterFilter(&#39;pre&#39;, $function);
  }
  /**
   * Registers a postfilter function to apply
   * to a compiled template after compilation
   *
   * @param callable $function
   */
  public function register_postfilter($function)
  {
    $this->registerFilter(&#39;post&#39;, $function);
  }
  /**
   * Unregisters a postfilter function
   *
   * @param callable $function
   */
  public function unregister_postfilter($function)
  {
    $this->unregisterFilter(&#39;post&#39;, $function);
  }
  /**
   * Registers an output filter function to apply
   * to a template output
   *
   * @param callable $function
   */
  public function register_outputfilter($function)
  {
    $this->registerFilter(&#39;output&#39;, $function);
  }
  /**
   * Unregisters an outputfilter function
   *
   * @param callable $function
   */
  public function unregister_outputfilter($function)
  {
    $this->unregisterFilter(&#39;output&#39;, $function);
  }
  /**
   * load a filter of specified type and name
   *
   * @param string $type filter type
   * @param string $name filter name
   */
  public function load_filter($type, $name)
  {
    $this->loadFilter($type, $name);
  }
  /**
   * clear cached content for the given template and cache id
   *
   * @param string $tpl_file  name of template file
   * @param string $cache_id  name of cache_id
   * @param string $compile_id name of compile_id
   * @param string $exp_time  expiration time
   *
   * @return boolean
   */
  public function clear_cache($tpl_file = null, $cache_id = null, $compile_id = null, $exp_time = null)
  {
    return $this->clearCache($tpl_file, $cache_id, $compile_id, $exp_time);
  }
  /**
   * clear the entire contents of cache (all templates)
   *
   * @param string $exp_time expire time
   *
   * @return boolean
   */
  public function clear_all_cache($exp_time = null)
  {
    return $this->clearCache(null, null, null, $exp_time);
  }
  /**
   * test to see if valid cache exists for this template
   *
   * @param string $tpl_file name of template file
   * @param string $cache_id
   * @param string $compile_id
   *
   * @return boolean
   */
  public function is_cached($tpl_file, $cache_id = null, $compile_id = null)
  {
    return $this->isCached($tpl_file, $cache_id, $compile_id);
  }
  /**
   * clear all the assigned template variables.
   */
  public function clear_all_assign()
  {
    $this->clearAllAssign();
  }
  /**
   * clears compiled version of specified template resource,
   * or all compiled template files if one is not specified.
   * This function is for advanced use only, not normally needed.
   *
   * @param string $tpl_file
   * @param string $compile_id
   * @param string $exp_time
   *
   * @return boolean results of {@link smarty_core_rm_auto()}
   */
  public function clear_compiled_tpl($tpl_file = null, $compile_id = null, $exp_time = null)
  {
    return $this->clearCompiledTemplate($tpl_file, $compile_id, $exp_time);
  }
  /**
   * Checks whether requested template exists.
   *
   * @param string $tpl_file
   *
   * @return boolean
   */
  public function template_exists($tpl_file)
  {
    return $this->templateExists($tpl_file);
  }
  /**
   * Returns an array containing template variables
   *
   * @param string $name
   *
   * @return array
   */
  public function get_template_vars($name = null)
  {
    return $this->getTemplateVars($name);
  }
  /**
   * Returns an array containing config variables
   *
   * @param string $name
   *
   * @return array
   */
  public function get_config_vars($name = null)
  {
    return $this->getConfigVars($name);
  }
  /**
   * load configuration values
   *
   * @param string $file
   * @param string $section
   * @param string $scope
   */
  public function config_load($file, $section = null, $scope = &#39;global&#39;)
  {
    $this->ConfigLoad($file, $section, $scope);
  }
  /**
   * return a reference to a registered object
   *
   * @param string $name
   *
   * @return object
   */
  public function get_registered_object($name)
  {
    return $this->getRegisteredObject($name);
  }
  /**
   * clear configuration values
   *
   * @param string $var
   */
  public function clear_config($var = null)
  {
    $this->clearConfig($var);
  }
  /**
   * trigger Smarty error
   *
   * @param string $error_msg
   * @param integer $error_type
   */
  public function trigger_error($error_msg, $error_type = E_USER_WARNING)
  {
    trigger_error("Smarty error: $error_msg", $error_type);
  }
}
/**
 * Smarty {php}{/php} block function
 *
 * @param array  $params  parameter list
 * @param string $content contents of the block
 * @param object $template template object
 * @param boolean &$repeat repeat flag
 *
 * @return string content re-formatted
 */
function smarty_php_tag($params, $content, $template, &$repeat)
{
  eval($content);
  return &#39;&#39;;
}
Copy after login
Summary: The above is the entire content of this article, I hope it will be helpful to everyone's study.
Related recommendations:
PHP database redis usage and analysis
How to handle non-form data when PHP Post cannot obtain it
phpDetailed explanation of how to record the search engine crawling process
The above is the detailed content of PHP encapsulated smartBC class. For more information, please follow other related articles on the PHP Chinese website!