vendor/smarty/smarty/libs/SmartyBC.class.php

   1 <?php
   2 /**
   3  * Project:     Smarty: the PHP compiling template engine
   4  * File:        SmartyBC.class.php
   5  * SVN:         $Id: $
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  * For questions, help, comments, discussion, etc., please join the
  18  * Smarty mailing list. Send a blank e-mail to
  19  * smarty-discussion-subscribe@googlegroups.com
  20  *
  21  * @link      http://www.smarty.net/
  22  * @copyright 2008 New Digital Group, Inc.
  23  * @author    Monte Ohrt <monte at ohrt dot com>
  24  * @author    Uwe Tews
  25  * @author    Rodney Rehm
  26  * @package   Smarty
  27  */
  28 /**
  29  * @ignore
  30  */
  31 require_once(dirname(__FILE__) . '/Smarty.class.php');
  32
  33 /**
  34  * Smarty Backward Compatibility Wrapper Class
  35  *
  36  * @package Smarty
  37  */
  38 class SmartyBC extends Smarty
  39 {
  40     /**
  41      * Smarty 2 BC
  42      *
  43      * @var string
  44      */
  45     public $_version = self::SMARTY_VERSION;
  46
  47     /**
  48      * This is an array of directories where trusted php scripts reside.
  49      *
  50      * @var array
  51      */
  52     public $trusted_dir = array();
  53
  54     /**
  55      * Initialize new SmartyBC object
  56      *
  57      */
  58     public function __construct()
  59     {
  60         parent::__construct();
  61     }
  62
  63     /**
  64      * wrapper for assign_by_ref
  65      *
  66      * @param string $tpl_var the template variable name
  67      * @param mixed  &$value  the referenced value to assign
  68      */
  69     public function assign_by_ref($tpl_var, &$value)
  70     {
  71         $this->assignByRef($tpl_var, $value);
  72     }
  73
  74     /**
  75      * wrapper for append_by_ref
  76      *
  77      * @param string  $tpl_var the template variable name
  78      * @param mixed   &$value  the referenced value to append
  79      * @param boolean $merge   flag if array elements shall be merged
  80      */
  81     public function append_by_ref($tpl_var, &$value, $merge = false)
  82     {
  83         $this->appendByRef($tpl_var, $value, $merge);
  84     }
  85
  86     /**
  87      * clear the given assigned template variable.
  88      *
  89      * @param string $tpl_var the template variable to clear
  90      */
  91     public function clear_assign($tpl_var)
  92     {
  93         $this->clearAssign($tpl_var);
  94     }
  95
  96     /**
  97      * Registers custom function to be used in templates
  98      *
  99      * @param string $function      the name of the template function
 100      * @param string $function_impl the name of the PHP function to register
 101      * @param bool   $cacheable
 102      * @param mixed  $cache_attrs
 103      */
 104     public function register_function($function, $function_impl, $cacheable = true, $cache_attrs = null)
 105     {
 106         $this->registerPlugin('function', $function, $function_impl, $cacheable, $cache_attrs);
 107     }
 108
 109     /**
 110      * Unregister custom function
 111      *
 112      * @param string $function name of template function
 113      */
 114     public function unregister_function($function)
 115     {
 116         $this->unregisterPlugin('function', $function);
 117     }
 118
 119     /**
 120      * Registers object to be used in templates
 121      *
 122      * @param string  $object        name of template object
 123      * @param object  $object_impl   the referenced PHP object to register
 124      * @param array   $allowed       list of allowed methods (empty = all)
 125      * @param boolean $smarty_args   smarty argument format, else traditional
 126      * @param array   $block_methods list of methods that are block format
 127      *
 128      * @throws SmartyException
 129      * @internal param array $block_functs list of methods that are block format
 130      */
 131     public function register_object($object, $object_impl, $allowed = array(), $smarty_args = true,
 132                                     $block_methods = array())
 133     {
 134         settype($allowed, 'array');
 135         settype($smarty_args, 'boolean');
 136         $this->registerObject($object, $object_impl, $allowed, $smarty_args, $block_methods);
 137     }
 138
 139     /**
 140      * Unregister object
 141      *
 142      * @param string $object name of template object
 143      */
 144     public function unregister_object($object)
 145     {
 146         $this->unregisterObject($object);
 147     }
 148
 149     /**
 150      * Registers block function to be used in templates
 151      *
 152      * @param string $block      name of template block
 153      * @param string $block_impl PHP function to register
 154      * @param bool   $cacheable
 155      * @param mixed  $cache_attrs
 156      */
 157     public function register_block($block, $block_impl, $cacheable = true, $cache_attrs = null)
 158     {
 159         $this->registerPlugin('block', $block, $block_impl, $cacheable, $cache_attrs);
 160     }
 161
 162     /**
 163      * Unregister block function
 164      *
 165      * @param string $block name of template function
 166      */
 167     public function unregister_block($block)
 168     {
 169         $this->unregisterPlugin('block', $block);
 170     }
 171
 172     /**
 173      * Registers compiler function
 174      *
 175      * @param string $function      name of template function
 176      * @param string $function_impl name of PHP function to register
 177      * @param bool   $cacheable
 178      */
 179     public function register_compiler_function($function, $function_impl, $cacheable = true)
 180     {
 181         $this->registerPlugin('compiler', $function, $function_impl, $cacheable);
 182     }
 183
 184     /**
 185      * Unregister compiler function
 186      *
 187      * @param string $function name of template function
 188      */
 189     public function unregister_compiler_function($function)
 190     {
 191         $this->unregisterPlugin('compiler', $function);
 192     }
 193
 194     /**
 195      * Registers modifier to be used in templates
 196      *
 197      * @param string $modifier      name of template modifier
 198      * @param string $modifier_impl name of PHP function to register
 199      */
 200     public function register_modifier($modifier, $modifier_impl)
 201     {
 202         $this->registerPlugin('modifier', $modifier, $modifier_impl);
 203     }
 204
 205     /**
 206      * Unregister modifier
 207      *
 208      * @param string $modifier name of template modifier
 209      */
 210     public function unregister_modifier($modifier)
 211     {
 212         $this->unregisterPlugin('modifier', $modifier);
 213     }
 214
 215     /**
 216      * Registers a resource to fetch a template
 217      *
 218      * @param string $type      name of resource
 219      * @param array  $functions array of functions to handle resource
 220      */
 221     public function register_resource($type, $functions)
 222     {
 223         $this->registerResource($type, $functions);
 224     }
 225
 226     /**
 227      * Unregister a resource
 228      *
 229      * @param string $type name of resource
 230      */
 231     public function unregister_resource($type)
 232     {
 233         $this->unregisterResource($type);
 234     }
 235
 236     /**
 237      * Registers a prefilter function to apply
 238      * to a template before compiling
 239      *
 240      * @param callable $function
 241      */
 242     public function register_prefilter($function)
 243     {
 244         $this->registerFilter('pre', $function);
 245     }
 246
 247     /**
 248      * Unregister a prefilter function
 249      *
 250      * @param callable $function
 251      */
 252     public function unregister_prefilter($function)
 253     {
 254         $this->unregisterFilter('pre', $function);
 255     }
 256
 257     /**
 258      * Registers a postfilter function to apply
 259      * to a compiled template after compilation
 260      *
 261      * @param callable $function
 262      */
 263     public function register_postfilter($function)
 264     {
 265         $this->registerFilter('post', $function);
 266     }
 267
 268     /**
 269      * Unregister a postfilter function
 270      *
 271      * @param callable $function
 272      */
 273     public function unregister_postfilter($function)
 274     {
 275         $this->unregisterFilter('post', $function);
 276     }
 277
 278     /**
 279      * Registers an output filter function to apply
 280      * to a template output
 281      *
 282      * @param callable $function
 283      */
 284     public function register_outputfilter($function)
 285     {
 286         $this->registerFilter('output', $function);
 287     }
 288
 289     /**
 290      * Unregister an outputfilter function
 291      *
 292      * @param callable $function
 293      */
 294     public function unregister_outputfilter($function)
 295     {
 296         $this->unregisterFilter('output', $function);
 297     }
 298
 299     /**
 300      * load a filter of specified type and name
 301      *
 302      * @param string $type filter type
 303      * @param string $name filter name
 304      */
 305     public function load_filter($type, $name)
 306     {
 307         $this->loadFilter($type, $name);
 308     }
 309
 310     /**
 311      * clear cached content for the given template and cache id
 312      *
 313      * @param  string $tpl_file   name of template file
 314      * @param  string $cache_id   name of cache_id
 315      * @param  string $compile_id name of compile_id
 316      * @param  string $exp_time   expiration time
 317      *
 318      * @return boolean
 319      */
 320     public function clear_cache($tpl_file = null, $cache_id = null, $compile_id = null, $exp_time = null)
 321     {
 322         return $this->clearCache($tpl_file, $cache_id, $compile_id, $exp_time);
 323     }
 324
 325     /**
 326      * clear the entire contents of cache (all templates)
 327      *
 328      * @param  string $exp_time expire time
 329      *
 330      * @return boolean
 331      */
 332     public function clear_all_cache($exp_time = null)
 333     {
 334         return $this->clearCache(null, null, null, $exp_time);
 335     }
 336
 337     /**
 338      * test to see if valid cache exists for this template
 339      *
 340      * @param  string $tpl_file name of template file
 341      * @param  string $cache_id
 342      * @param  string $compile_id
 343      *
 344      * @return boolean
 345      */
 346     public function is_cached($tpl_file, $cache_id = null, $compile_id = null)
 347     {
 348         return $this->isCached($tpl_file, $cache_id, $compile_id);
 349     }
 350
 351     /**
 352      * clear all the assigned template variables.
 353      */
 354     public function clear_all_assign()
 355     {
 356         $this->clearAllAssign();
 357     }
 358
 359     /**
 360      * clears compiled version of specified template resource,
 361      * or all compiled template files if one is not specified.
 362      * This function is for advanced use only, not normally needed.
 363      *
 364      * @param  string $tpl_file
 365      * @param  string $compile_id
 366      * @param  string $exp_time
 367      *
 368      * @return boolean results of {@link smarty_core_rm_auto()}
 369      */
 370     public function clear_compiled_tpl($tpl_file = null, $compile_id = null, $exp_time = null)
 371     {
 372         return $this->clearCompiledTemplate($tpl_file, $compile_id, $exp_time);
 373     }
 374
 375     /**
 376      * Checks whether requested template exists.
 377      *
 378      * @param  string $tpl_file
 379      *
 380      * @return boolean
 381      */
 382     public function template_exists($tpl_file)
 383     {
 384         return $this->templateExists($tpl_file);
 385     }
 386
 387     /**
 388      * Returns an array containing template variables
 389      *
 390      * @param  string $name
 391      *
 392      * @return array
 393      */
 394     public function get_template_vars($name = null)
 395     {
 396         return $this->getTemplateVars($name);
 397     }
 398
 399     /**
 400      * Returns an array containing config variables
 401      *
 402      * @param  string $name
 403      *
 404      * @return array
 405      */
 406     public function get_config_vars($name = null)
 407     {
 408         return $this->getConfigVars($name);
 409     }
 410
 411     /**
 412      * load configuration values
 413      *
 414      * @param string $file
 415      * @param string $section
 416      * @param string $scope
 417      */
 418     public function config_load($file, $section = null, $scope = 'global')
 419     {
 420         $this->ConfigLoad($file, $section, $scope);
 421     }
 422
 423     /**
 424      * return a reference to a registered object
 425      *
 426      * @param  string $name
 427      *
 428      * @return object
 429      */
 430     public function get_registered_object($name)
 431     {
 432         return $this->getRegisteredObject($name);
 433     }
 434
 435     /**
 436      * clear configuration values
 437      *
 438      * @param string $var
 439      */
 440     public function clear_config($var = null)
 441     {
 442         $this->clearConfig($var);
 443     }
 444
 445     /**
 446      * trigger Smarty error
 447      *
 448      * @param string  $error_msg
 449      * @param integer $error_type
 450      */
 451     public function trigger_error($error_msg, $error_type = E_USER_WARNING)
 452     {
 453         trigger_error("Smarty error: $error_msg", $error_type);
 454     }
 455 }