YiiBase.php 21.3 KB
Newer Older
Qiang Xue committed
1
<?php
w  
Qiang Xue committed
2 3
/**
 * @link http://www.yiiframework.com/
Qiang Xue committed
4
 * @copyright Copyright (c) 2008 Yii Software LLC
w  
Qiang Xue committed
5 6
 * @license http://www.yiiframework.com/license/
 */
7 8
namespace yii;

Qiang Xue committed
9
use yii\base\Exception;
Qiang Xue committed
10
use yii\base\InvalidConfigException;
Qiang Xue committed
11
use yii\base\InvalidParamException;
12
use yii\base\UnknownClassException;
Qiang Xue committed
13
use yii\log\Logger;
Qiang Xue committed
14

Qiang Xue committed
15
/**
w  
Qiang Xue committed
16
 * Gets the application start timestamp.
Qiang Xue committed
17
 */
w  
Qiang Xue committed
18
defined('YII_BEGIN_TIME') or define('YII_BEGIN_TIME', microtime(true));
19 20 21 22
/**
 * This constant defines the framework installation directory.
 */
defined('YII_PATH') or define('YII_PATH', __DIR__);
Qiang Xue committed
23 24 25
/**
 * This constant defines whether the application should be in debug mode or not. Defaults to false.
 */
w  
Qiang Xue committed
26
defined('YII_DEBUG') or define('YII_DEBUG', false);
27 28 29 30 31
/**
 * This constant defines in which environment the application is running. Defaults to 'prod', meaning production environment.
 * You may define this constant in the bootstrap script. The value could be 'prod' (production), 'dev' (development), 'test', 'staging', etc.
 */
defined('YII_ENV') or define('YII_ENV', 'prod');
Qiang Xue committed
32
/**
33
 * Whether the the application is running in production environment
Qiang Xue committed
34
 */
35 36 37 38 39 40 41 42 43 44
defined('YII_ENV_PROD') or define('YII_ENV_PROD', YII_ENV === 'prod');
/**
 * Whether the the application is running in development environment
 */
defined('YII_ENV_DEV') or define('YII_ENV_DEV', YII_ENV === 'dev');
/**
 * Whether the the application is running in testing environment
 */
defined('YII_ENV_TEST') or define('YII_ENV_TEST', YII_ENV === 'test');

Qiang Xue committed
45 46 47 48 49
/**
 * This constant defines whether error handling should be enabled. Defaults to true.
 */
defined('YII_ENABLE_ERROR_HANDLER') or define('YII_ENABLE_ERROR_HANDLER', true);

w  
Qiang Xue committed
50

Qiang Xue committed
51
/**
w  
Qiang Xue committed
52
 * YiiBase is the core helper class for the Yii framework.
Qiang Xue committed
53
 *
w  
Qiang Xue committed
54
 * Do not use YiiBase directly. Instead, use its child class [[Yii]] where
Qiang Xue committed
55 56 57
 * you can customize methods of YiiBase.
 *
 * @author Qiang Xue <qiang.xue@gmail.com>
w  
Qiang Xue committed
58
 * @since 2.0
Qiang Xue committed
59 60 61 62 63
 */
class YiiBase
{
	/**
	 * @var array class map used by the Yii autoloading mechanism.
64
	 * The array keys are the class names (without leading backslashes), and the array values
Qiang Xue committed
65 66
	 * are the corresponding class file paths (or path aliases). This property mainly affects
	 * how [[autoload()]] works.
Qiang Xue committed
67 68
	 * @see import
	 * @see autoload
w  
Qiang Xue committed
69 70 71
	 */
	public static $classMap = array();
	/**
72
	 * @var \yii\console\Application|\yii\web\Application the application instance
Qiang Xue committed
73
	 */
Qiang Xue committed
74
	public static $app;
w  
Qiang Xue committed
75 76
	/**
	 * @var array registered path aliases
Qiang Xue committed
77 78
	 * @see getAlias
	 * @see setAlias
w  
Qiang Xue committed
79
	 */
80
	public static $aliases = array('@yii' => __DIR__);
Qiang Xue committed
81 82
	/**
	 * @var array initial property values that will be applied to objects newly created via [[createObject]].
Qiang Xue committed
83 84
	 * The array keys are class names without leading backslashes "\", and the array values are the corresponding
	 * name-value pairs for initializing the created class instances. For example,
Qiang Xue committed
85 86 87
	 *
	 * ~~~
	 * array(
Qiang Xue committed
88
	 *     'Bar' => array(
Qiang Xue committed
89 90 91
	 *         'prop1' => 'value1',
	 *         'prop2' => 'value2',
	 *     ),
Qiang Xue committed
92
	 *     'mycompany\foo\Car' => array(
Qiang Xue committed
93 94 95 96 97 98 99 100 101
	 *         'prop1' => 'value1',
	 *         'prop2' => 'value2',
	 *     ),
	 * )
	 * ~~~
	 *
	 * @see createObject
	 */
	public static $objectConfig = array();
Qiang Xue committed
102

Qiang Xue committed
103
	private static $_imported = array(); // alias => class name or directory
Qiang Xue committed
104 105 106 107 108 109

	/**
	 * @return string the version of Yii framework
	 */
	public static function getVersion()
	{
w  
Qiang Xue committed
110
		return '2.0-dev';
Qiang Xue committed
111 112 113
	}

	/**
Qiang Xue committed
114
	 * Imports a class by its alias.
Qiang Xue committed
115
	 *
Qiang Xue committed
116 117 118
	 * This method is provided to support autoloading of non-namespaced classes.
	 * Such a class can be specified in terms of an alias. For example, the alias `@old/code/Sample`
	 * may represent the `Sample` class under the directory `@old/code` (a path alias).
Qiang Xue committed
119
	 *
Qiang Xue committed
120 121 122 123
	 * By importing a class, the class is put in an internal storage such that when
	 * the class is used for the first time, the class autoloader will be able to
	 * find the corresponding class file and include it. For this reason, this method
	 * is much lighter than `include()`.
Qiang Xue committed
124
	 *
Qiang Xue committed
125
	 * You may import the same class multiple times. Only the first importing will count.
Qiang Xue committed
126
	 *
Qiang Xue committed
127 128 129 130
	 * @param string $alias the class to be imported. This may be either a class alias or a fully-qualified class name.
	 * If the latter, it will be returned back without change.
	 * @return string the actual class name that `$alias` refers to
	 * @throws Exception if the alias is invalid
Qiang Xue committed
131
	 */
Qiang Xue committed
132
	public static function import($alias)
Qiang Xue committed
133
	{
Qiang Xue committed
134
		if (strncmp($alias, '@', 1)) {
Qiang Xue committed
135
			return $alias;
Qiang Xue committed
136 137 138 139
		} else {
			$alias = static::getAlias($alias);
			if (!isset(self::$_imported[$alias])) {
				$className = basename($alias);
w  
Qiang Xue committed
140
				self::$_imported[$alias] = $className;
Qiang Xue committed
141
				self::$classMap[$className] = $alias . '.php';
w  
Qiang Xue committed
142
			}
Qiang Xue committed
143
			return self::$_imported[$alias];
Qiang Xue committed
144 145 146
		}
	}

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
	/**
	 * Imports a set of namespaces.
	 *
	 * By importing a namespace, the method will create an alias for the directory corresponding
	 * to the namespace. For example, if "foo\bar" is a namespace associated with the directory
	 * "path/to/foo/bar", then an alias "@foo/bar" will be created for this directory.
	 *
	 * This method is typically invoked in the bootstrap file to import the namespaces of
	 * the installed extensions. By default, Composer, when installing new extensions, will
	 * generate such a mapping file which can be loaded and passed to this method.
	 *
	 * @param array $namespaces the namespaces to be imported. The keys are the namespaces,
	 * and the values are the corresponding directories.
	 */
	public static function importNamespaces($namespaces)
	{
		foreach ($namespaces as $name => $path) {
			if ($name !== '') {
165
				$name = trim(strtr($name, array('\\' => '/', '_' => '/')), '/');
166 167 168
				if (is_array($path)) {
					$path = reset($path);
				}
169
				static::setAlias('@' . $name, rtrim($path, '/\\') . '/' . $name);
170 171 172 173
			}
		}
	}

Qiang Xue committed
174
	/**
w  
Qiang Xue committed
175
	 * Translates a path alias into an actual path.
m  
Qiang Xue committed
176
	 *
177
	 * The translation is done according to the following procedure:
m  
Qiang Xue committed
178
	 *
179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195
	 * 1. If the given alias does not start with '@', it is returned back without change;
	 * 2. Otherwise, look for the longest registered alias that matches the beginning part
	 *    of the given alias. If it exists, replace the matching part of the given alias with
	 *    the corresponding registered path.
	 * 3. Throw an exception or return false, depending on the `$throwException` parameter.
	 *
	 * For example, by default '@yii' is registered as the alias to the Yii framework directory,
	 * say '/path/to/yii'. The alias '@yii/web' would then be translated into '/path/to/yii/web'.
	 *
	 * If you have registered two aliases '@foo' and '@foo/bar'. Then translating '@foo/bar/config'
	 * would replace the part '@foo/bar' (instead of '@foo') with the corresponding registered path.
	 * This is because the longest alias takes precedence.
	 *
	 * However, if the alias to be translated is '@foo/barbar/config', then '@foo' will be replaced
	 * instead of '@foo/bar', because '/' serves as the boundary character.
	 *
	 * Note, this method does not check if the returned path exists or not.
w  
Qiang Xue committed
196
	 *
Qiang Xue committed
197
	 * @param string $alias the alias to be translated.
Qiang Xue committed
198 199
	 * @param boolean $throwException whether to throw an exception if the given alias is invalid.
	 * If this is false and an invalid alias is given, false will be returned by this method.
Qiang Xue committed
200
	 * @return string|boolean the path corresponding to the alias, false if the root alias is not previously registered.
Qiang Xue committed
201
	 * @throws InvalidParamException if the alias is invalid while $throwException is true.
w  
Qiang Xue committed
202
	 * @see setAlias
Qiang Xue committed
203
	 */
Qiang Xue committed
204
	public static function getAlias($alias, $throwException = true)
Qiang Xue committed
205
	{
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
		if (strncmp($alias, '@', 1)) {
			// not an alias
			return $alias;
		}

		$pos = strpos($alias, '/');
		$root = $pos === false ? $alias : substr($alias, 0, $pos);

		if (isset(self::$aliases[$root])) {
			if (is_string(self::$aliases[$root])) {
				return $pos === false ? self::$aliases[$root] : self::$aliases[$root] . substr($alias, $pos);
			} else {
				foreach (self::$aliases[$root] as $name => $path) {
					if (strpos($alias . '/', $name . '/') === 0) {
						return $path . substr($alias, strlen($name));
					}
Qiang Xue committed
222
				}
Qiang Xue committed
223 224
			}
		}
225

Qiang Xue committed
226 227 228 229 230
		if ($throwException) {
			throw new InvalidParamException("Invalid path alias: $alias");
		} else {
			return false;
		}
Qiang Xue committed
231 232
	}

Qiang Xue committed
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
	/**
	 * Returns the root alias part of a given alias.
	 * A root alias is an alias that has been registered via [[setAlias()]] previously.
	 * If a given alias matches multiple root aliases, the longest one will be returned.
	 * @param string $alias the alias
	 * @return string|boolean the root alias, or false if no root alias is found
	 */
	public static function getRootAlias($alias)
	{
		$pos = strpos($alias, '/');
		$root = $pos === false ? $alias : substr($alias, 0, $pos);

		if (isset(self::$aliases[$root])) {
			if (is_string(self::$aliases[$root])) {
				return $root;
			} else {
				foreach (self::$aliases[$root] as $name => $path) {
					if (strpos($alias . '/', $name . '/') === 0) {
						return $name;
					}
				}
			}
		}
		return false;
	}

Qiang Xue committed
259
	/**
w  
Qiang Xue committed
260
	 * Registers a path alias.
m  
Qiang Xue committed
261
	 *
262 263
	 * A path alias is a short name representing a long path (a file path, a URL, etc.)
	 * For example, we use '@yii' as the alias of the path to the Yii framework directory.
m  
Qiang Xue committed
264
	 *
265 266
	 * A path alias must start with the character '@' so that it can be easily differentiated
	 * from non-alias paths.
m  
Qiang Xue committed
267
	 *
268 269 270 271 272 273 274 275 276 277
	 * Note that this method does not check if the given path exists or not. All it does is
	 * to associate the alias with the path.
	 *
	 * Any trailing '/' and '\' characters in the given path will be trimmed.
	 *
	 * @param string $alias the alias name (e.g. "@yii"). It must start with a '@' character.
	 * It may contain the forward slash '/' which serves as boundary character when performing
	 * alias translation by [[getAlias()]].
	 * @param string $path the path corresponding to the alias. Trailing '/' and '\' characters
	 * will be trimmed. This can be
m  
Qiang Xue committed
278 279 280 281
	 *
	 * - a directory or a file path (e.g. `/tmp`, `/tmp/main.txt`)
	 * - a URL (e.g. `http://www.yiiframework.com`)
	 * - a path alias (e.g. `@yii/base`). In this case, the path alias will be converted into the
Qiang Xue committed
282
	 *   actual path first by calling [[getAlias()]].
Qiang Xue committed
283
	 *
Qiang Xue committed
284
	 * @throws InvalidParamException if $path is an invalid alias.
w  
Qiang Xue committed
285
	 * @see getAlias
Qiang Xue committed
286
	 */
w  
Qiang Xue committed
287
	public static function setAlias($alias, $path)
Qiang Xue committed
288
	{
289
		if (strncmp($alias, '@', 1)) {
Qiang Xue committed
290
			$alias = '@' . $alias;
291 292 293 294 295 296
		}
		$pos = strpos($alias, '/');
		$root = $pos === false ? $alias : substr($alias, 0, $pos);
		if ($path !== null) {
			$path = strncmp($path, '@', 1) ? rtrim($path, '\\/') : static::getAlias($path);
			if (!isset(self::$aliases[$root])) {
Qiang Xue committed
297 298 299 300 301
				if ($pos === false) {
					self::$aliases[$root] = $path;
				} else {
					self::$aliases[$root] = array($alias => $path);
				}
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320
			} elseif (is_string(self::$aliases[$root])) {
				if ($pos === false) {
					self::$aliases[$root] = $path;
				} else {
					self::$aliases[$root] = array(
						$alias => $path,
						$root => self::$aliases[$root],
					);
				}
			} else {
				self::$aliases[$root][$alias] = $path;
				krsort(self::$aliases[$root]);
			}
		} elseif (isset(self::$aliases[$root])) {
			if (is_array(self::$aliases[$root])) {
				unset(self::$aliases[$root][$alias]);
			} elseif ($pos === false) {
				unset(self::$aliases[$root]);
			}
m  
Qiang Xue committed
321
		}
Qiang Xue committed
322 323 324 325
	}

	/**
	 * Class autoload loader.
Qiang Xue committed
326 327
	 * This method is invoked automatically when PHP sees an unknown class.
	 * The method will attempt to include the class file according to the following procedure:
w  
Qiang Xue committed
328 329 330 331 332 333 334 335 336
	 *
	 * 1. Search in [[classMap]];
	 * 2. If the class is namespaced (e.g. `yii\base\Component`), it will attempt
	 *    to include the file associated with the corresponding path alias
	 *    (e.g. `@yii/base/Component.php`);
	 * 3. If the class is named in PEAR style (e.g. `PHPUnit_Framework_TestCase`),
	 *    it will attempt to include the file associated with the corresponding path alias
	 *    (e.g. `@PHPUnit/Framework/TestCase.php`);
	 *
337 338 339
	 * This autoloader allows loading classes that follow the [PSR-0 standard](http://www.php-fig.org/psr/0/).
	 * Therefor a path alias has to be defined for each top-level namespace.
	 *
340
	 * @param string $className the fully qualified class name without a leading backslash "\"
341
	 * @throws UnknownClassException if the class does not exist in the class file
Qiang Xue committed
342 343 344
	 */
	public static function autoload($className)
	{
Qiang Xue committed
345
		if (isset(self::$classMap[$className])) {
346 347 348
			$classFile = self::$classMap[$className];
			if ($classFile[0] === '@') {
				$classFile = static::getAlias($classFile);
Qiang Xue committed
349
			}
Qiang Xue committed
350
		} else {
Qiang Xue committed
351
			// follow PSR-0 to determine the class file
Qiang Xue committed
352 353
			if (($pos = strrpos($className, '\\')) !== false) {
				// namespaced class, e.g. yii\base\Component
Qiang Xue committed
354
				$path = str_replace('\\', '/', substr($className, 0, $pos + 1))
Qiang Xue committed
355 356
					. str_replace('_', '/', substr($className, $pos + 1)) . '.php';
			} else {
Qiang Xue committed
357
				$path = str_replace('_', '/', $className) . '.php';
w  
Qiang Xue committed
358
			}
Qiang Xue committed
359

360
			// try loading via path alias
361 362 363
			if (strpos($path, '/') === false) {
				return;
			} else {
364
				$classFile = static::getAlias('@' . $path, false);
365 366
				if ($classFile === false || !is_file($classFile)) {
					return;
Qiang Xue committed
367
				}
Qiang Xue committed
368
			}
w  
Qiang Xue committed
369
		}
370 371 372 373 374 375 376

		include($classFile);

		if (!class_exists($className, false) && !interface_exists($className, false) &&
			(!function_exists('trait_exists') || !trait_exists($className, false))) {
			throw new UnknownClassException("Unable to find '$className' in file: $classFile");
		}
Qiang Xue committed
377 378
	}

w  
Qiang Xue committed
379
	/**
Qiang Xue committed
380
	 * Creates a new object using the given configuration.
w  
Qiang Xue committed
381
	 *
Qiang Xue committed
382
	 * The configuration can be either a string or an array.
Qiang Xue committed
383 384
	 * If a string, it is treated as the *object class*; if an array,
	 * it must contain a `class` element specifying the *object class*, and
w  
Qiang Xue committed
385 386 387
	 * the rest of the name-value pairs in the array will be used to initialize
	 * the corresponding object properties.
	 *
Qiang Xue committed
388
	 * The object type can be either a class name or the [[getAlias()|alias]] of
w  
Qiang Xue committed
389
	 * the class. For example,
w  
Qiang Xue committed
390
	 *
Qiang Xue committed
391 392
	 * - `app\components\GoogleMap`: fully-qualified namespaced class.
	 * - `@app/components/GoogleMap`: an alias, used for non-namespaced class.
Qiang Xue committed
393 394 395
	 *
	 * Below are some usage examples:
	 *
w  
Qiang Xue committed
396
	 * ~~~
Qiang Xue committed
397
	 * $object = \Yii::createObject('@app/components/GoogleMap');
Qiang Xue committed
398 399
	 * $object = \Yii::createObject(array(
	 *     'class' => '\app\components\GoogleMap',
w  
Qiang Xue committed
400 401 402 403
	 *     'apiKey' => 'xyz',
	 * ));
	 * ~~~
	 *
Qiang Xue committed
404 405 406 407 408 409 410 411 412 413
	 * This method can be used to create any object as long as the object's constructor is
	 * defined like the following:
	 *
	 * ~~~
	 * public function __construct(..., $config = array()) {
	 * }
	 * ~~~
	 *
	 * The method will pass the given configuration as the last parameter of the constructor,
	 * and any additional parameters to this method will be passed as the rest of the constructor parameters.
w  
Qiang Xue committed
414
	 *
Qiang Xue committed
415 416
	 * @param string|array $config the configuration. It can be either a string representing the class name
	 * or an array representing the object configuration.
w  
Qiang Xue committed
417
	 * @return mixed the created object
Qiang Xue committed
418
	 * @throws InvalidConfigException if the configuration is invalid.
w  
Qiang Xue committed
419
	 */
Qiang Xue committed
420
	public static function createObject($config)
w  
Qiang Xue committed
421
	{
Qiang Xue committed
422 423
		static $reflections = array();

w  
Qiang Xue committed
424
		if (is_string($config)) {
w  
Qiang Xue committed
425
			$class = $config;
w  
Qiang Xue committed
426
			$config = array();
Qiang Xue committed
427
		} elseif (isset($config['class'])) {
w  
Qiang Xue committed
428
			$class = $config['class'];
w  
Qiang Xue committed
429
			unset($config['class']);
Qiang Xue committed
430
		} else {
Qiang Xue committed
431
			throw new InvalidConfigException('Object configuration must be an array containing a "class" element.');
w  
Qiang Xue committed
432 433
		}

w  
Qiang Xue committed
434
		if (!class_exists($class, false)) {
Qiang Xue committed
435
			$class = static::import($class);
w  
Qiang Xue committed
436 437
		}

Qiang Xue committed
438 439 440 441
		$class = ltrim($class, '\\');

		if (isset(self::$objectConfig[$class])) {
			$config = array_merge(self::$objectConfig[$class], $config);
442 443
		}

Qiang Xue committed
444
		if (($n = func_num_args()) > 1) {
Qiang Xue committed
445 446 447
			/** @var $reflection \ReflectionClass */
			if (isset($reflections[$class])) {
				$reflection = $reflections[$class];
Qiang Xue committed
448
			} else {
Qiang Xue committed
449 450 451 452
				$reflection = $reflections[$class] = new \ReflectionClass($class);
			}
			$args = func_get_args();
			array_shift($args); // remove $config
453
			if (!empty($config)) {
Qiang Xue committed
454
				$args[] = $config;
Qiang Xue committed
455
			}
Qiang Xue committed
456
			return $reflection->newInstanceArgs($args);
Qiang Xue committed
457
		} else {
458
			return empty($config) ? new $class : new $class($config);
Qiang Xue committed
459
		}
w  
Qiang Xue committed
460 461
	}

Qiang Xue committed
462
	/**
w  
Qiang Xue committed
463 464 465 466 467
	 * Logs a trace message.
	 * Trace messages are logged mainly for development purpose to see
	 * the execution work flow of some code.
	 * @param string $message the message to be logged.
	 * @param string $category the category of the message.
Qiang Xue committed
468
	 */
w  
Qiang Xue committed
469
	public static function trace($message, $category = 'application')
Qiang Xue committed
470
	{
w  
Qiang Xue committed
471
		if (YII_DEBUG) {
Qiang Xue committed
472
			self::$app->getLog()->log($message, Logger::LEVEL_TRACE, $category);
w  
Qiang Xue committed
473
		}
Qiang Xue committed
474 475 476
	}

	/**
w  
Qiang Xue committed
477 478 479 480 481
	 * Logs an error message.
	 * An error message is typically logged when an unrecoverable error occurs
	 * during the execution of an application.
	 * @param string $message the message to be logged.
	 * @param string $category the category of the message.
Qiang Xue committed
482
	 */
Qiang Xue committed
483
	public static function error($message, $category = 'application')
Qiang Xue committed
484
	{
Qiang Xue committed
485
		self::$app->getLog()->log($message, Logger::LEVEL_ERROR, $category);
w  
Qiang Xue committed
486 487 488 489 490 491 492 493 494
	}

	/**
	 * Logs a warning message.
	 * A warning message is typically logged when an error occurs while the execution
	 * can still continue.
	 * @param string $message the message to be logged.
	 * @param string $category the category of the message.
	 */
Qiang Xue committed
495
	public static function warning($message, $category = 'application')
w  
Qiang Xue committed
496
	{
Qiang Xue committed
497
		self::$app->getLog()->log($message, Logger::LEVEL_WARNING, $category);
Qiang Xue committed
498 499 500
	}

	/**
w  
Qiang Xue committed
501 502 503 504 505 506
	 * Logs an informative message.
	 * An informative message is typically logged by an application to keep record of
	 * something important (e.g. an administrator logs in).
	 * @param string $message the message to be logged.
	 * @param string $category the category of the message.
	 */
Qiang Xue committed
507
	public static function info($message, $category = 'application')
w  
Qiang Xue committed
508
	{
Qiang Xue committed
509
		self::$app->getLog()->log($message, Logger::LEVEL_INFO, $category);
w  
Qiang Xue committed
510 511 512 513 514 515 516 517 518
	}

	/**
	 * Marks the beginning of a code block for profiling.
	 * This has to be matched with a call to [[endProfile]] with the same category name.
	 * The begin- and end- calls must also be properly nested. For example,
	 *
	 * ~~~
	 * \Yii::beginProfile('block1');
Qiang Xue committed
519 520 521 522
	 * // some code to be profiled
	 *     \Yii::beginProfile('block2');
	 *     // some other code to be profiled
	 *     \Yii::endProfile('block2');
w  
Qiang Xue committed
523 524
	 * \Yii::endProfile('block1');
	 * ~~~
Qiang Xue committed
525 526
	 * @param string $token token for the code block
	 * @param string $category the category of this log message
Qiang Xue committed
527 528
	 * @see endProfile
	 */
Qiang Xue committed
529
	public static function beginProfile($token, $category = 'application')
Qiang Xue committed
530
	{
Qiang Xue committed
531
		self::$app->getLog()->log($token, Logger::LEVEL_PROFILE_BEGIN, $category);
Qiang Xue committed
532 533 534 535
	}

	/**
	 * Marks the end of a code block for profiling.
w  
Qiang Xue committed
536
	 * This has to be matched with a previous call to [[beginProfile]] with the same category name.
Qiang Xue committed
537 538
	 * @param string $token token for the code block
	 * @param string $category the category of this log message
Qiang Xue committed
539 540
	 * @see beginProfile
	 */
Qiang Xue committed
541
	public static function endProfile($token, $category = 'application')
Qiang Xue committed
542
	{
Qiang Xue committed
543
		self::$app->getLog()->log($token, Logger::LEVEL_PROFILE_END, $category);
Qiang Xue committed
544 545 546
	}

	/**
w  
Qiang Xue committed
547 548
	 * Returns an HTML hyperlink that can be displayed on your Web page showing Powered by Yii" information.
	 * @return string an HTML hyperlink that can be displayed on your Web page showing Powered by Yii" information
Qiang Xue committed
549 550 551
	 */
	public static function powered()
	{
Qiang Xue committed
552
		return 'Powered by <a href="http://www.yiiframework.com/" rel="external">Yii Framework</a>';
Qiang Xue committed
553 554 555 556
	}

	/**
	 * Translates a message to the specified language.
Qiang Xue committed
557
	 *
558 559 560
	 * This is a shortcut method of [[\yii\i18n\I18N::translate()]].
	 *
	 * The translation will be conducted according to the message category and the target language will be used.
Qiang Xue committed
561 562 563 564 565 566 567 568 569 570 571 572
	 *
	 * In case when a translated message has different plural forms (separated by "|"), this method
	 * will also attempt to choose an appropriate one according to a given numeric value which is
	 * specified as the first parameter (indexed by 0) in `$params`.
	 *
	 * For example, if a translated message is "I have an apple.|I have {n} apples.", and the first
	 * parameter is 2, the message returned will be "I have 2 apples.". Note that the placeholder "{n}"
	 * will be replaced with the given number.
	 *
	 * For more details on how plural rules are applied, please refer to:
	 * [[http://www.unicode.org/cldr/charts/supplemental/language_plural_rules.html]]
	 *
573
	 * @param string $category the message category.
Qiang Xue committed
574 575 576 577 578
	 * @param string $message the message to be translated.
	 * @param array $params the parameters that will be used to replace the corresponding placeholders in the message.
	 * @param string $language the language code (e.g. `en_US`, `en`). If this is null, the current
	 * [[\yii\base\Application::language|application language]] will be used.
	 * @return string the translated message.
Qiang Xue committed
579
	 */
580
	public static function t($category, $message, $params = array(), $language = null)
Qiang Xue committed
581
	{
Qiang Xue committed
582
		if (self::$app !== null) {
Qiang Xue committed
583
			return self::$app->getI18N()->translate($category, $message, $params, $language ?: self::$app->language);
Qiang Xue committed
584 585 586
		} else {
			return is_array($params) ? strtr($message, $params) : $message;
		}
Qiang Xue committed
587
	}
Qiang Xue committed
588 589 590 591 592 593 594 595 596 597 598 599

	/**
	 * Configures an object with the initial property values.
	 * @param object $object the object to be configured
	 * @param array $properties the property initial values given in terms of name-value pairs.
	 */
	public static function configure($object, $properties)
	{
		foreach ($properties as $name => $value) {
			$object->$name = $value;
		}
	}
600 601 602 603 604 605 606 607 608 609 610 611 612

	/**
	 * Returns the public member variables of an object.
	 * This method is provided such that we can get the public member variables of an object.
	 * It is different from "get_object_vars()" because the latter will return private
	 * and protected variables if it is called within the object itself.
	 * @param object $object the object to be handled
	 * @return array the public member variables of the object
	 */
	public static function getObjectVars($object)
	{
		return get_object_vars($object);
	}
Qiang Xue committed
613
}