gluon-web-remote

SmartyBC.class.php (12213B)

---

 <?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__) . '/Smarty.class.php');
 
 /**
  * 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( 'forceCompile' => false )
      */
     public function __construct(array $options = array())
     {
         parent::__construct($options);
     }
 
     /**
      * 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('function', $function, $function_impl, $cacheable, $cache_attrs);
     }
 
     /**
      * Unregisters custom function
      *
      * @param string $function name of template function
      */
     public function unregister_function($function)
     {
         $this->unregisterPlugin('function', $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, 'array');
         settype($smarty_args, 'boolean');
         $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('block', $block, $block_impl, $cacheable, $cache_attrs);
     }
 
     /**
      * Unregisters block function
      *
      * @param string $block name of template function
      */
     public function unregister_block($block)
     {
         $this->unregisterPlugin('block', $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('compiler', $function, $function_impl, $cacheable);
     }
 
     /**
      * Unregisters compiler function
      *
      * @param string $function name of template function
      */
     public function unregister_compiler_function($function)
     {
         $this->unregisterPlugin('compiler', $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('modifier', $modifier, $modifier_impl);
     }
 
     /**
      * Unregisters modifier
      *
      * @param string $modifier name of template modifier
      */
     public function unregister_modifier($modifier)
     {
         $this->unregisterPlugin('modifier', $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('pre', $function);
     }
 
     /**
      * Unregisters a prefilter function
      *
      * @param callable $function
      */
     public function unregister_prefilter($function)
     {
         $this->unregisterFilter('pre', $function);
     }
 
     /**
      * Registers a postfilter function to apply
      * to a compiled template after compilation
      *
      * @param callable $function
      */
     public function register_postfilter($function)
     {
         $this->registerFilter('post', $function);
     }
 
     /**
      * Unregisters a postfilter function
      *
      * @param callable $function
      */
     public function unregister_postfilter($function)
     {
         $this->unregisterFilter('post', $function);
     }
 
     /**
      * Registers an output filter function to apply
      * to a template output
      *
      * @param callable $function
      */
     public function register_outputfilter($function)
     {
         $this->registerFilter('output', $function);
     }
 
     /**
      * Unregisters an outputfilter function
      *
      * @param callable $function
      */
     public function unregister_outputfilter($function)
     {
         $this->unregisterFilter('output', $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 = 'global')
     {
         $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);
     }
 }