BaseYii.php 18.6 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\InvalidConfigException;
Qiang Xue committed
10
use yii\base\InvalidParamException;
11
use yii\base\UnknownClassException;
Qiang Xue committed
12
use yii\log\Logger;
Qiang Xue committed
13

Qiang Xue committed
14
/**
w  
Qiang Xue committed
15
 * Gets the application start timestamp.
Qiang Xue committed
16
 */
w  
Qiang Xue committed
17
defined('YII_BEGIN_TIME') or define('YII_BEGIN_TIME', microtime(true));
18 19 20 21
/**
 * This constant defines the framework installation directory.
 */
defined('YII_PATH') or define('YII_PATH', __DIR__);
Qiang Xue committed
22 23 24
/**
 * This constant defines whether the application should be in debug mode or not. Defaults to false.
 */
w  
Qiang Xue committed
25
defined('YII_DEBUG') or define('YII_DEBUG', false);
26 27 28 29 30
/**
 * 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
31
/**
32
 * Whether the the application is running in production environment
Qiang Xue committed
33
 */
34 35 36 37 38 39 40 41 42 43
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
44 45 46 47 48
/**
 * 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
49

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


	/**
	 * @return string the version of Yii framework
	 */
	public static function getVersion()
	{
Qiang Xue committed
107
		return '2.0.0-dev';
Qiang Xue committed
108 109 110
	}

	/**
w  
Qiang Xue committed
111
	 * Translates a path alias into an actual path.
m  
Qiang Xue committed
112
	 *
113
	 * The translation is done according to the following procedure:
m  
Qiang Xue committed
114
	 *
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
	 * 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
132
	 *
Qiang Xue committed
133
	 * @param string $alias the alias to be translated.
Qiang Xue committed
134 135
	 * @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
136
	 * @return string|boolean the path corresponding to the alias, false if the root alias is not previously registered.
Qiang Xue committed
137
	 * @throws InvalidParamException if the alias is invalid while $throwException is true.
138
	 * @see setAlias()
Qiang Xue committed
139
	 */
Qiang Xue committed
140
	public static function getAlias($alias, $throwException = true)
Qiang Xue committed
141
	{
142 143 144 145 146 147 148 149
		if (strncmp($alias, '@', 1)) {
			// not an alias
			return $alias;
		}

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

150 151 152
		if (isset(static::$aliases[$root])) {
			if (is_string(static::$aliases[$root])) {
				return $pos === false ? static::$aliases[$root] : static::$aliases[$root] . substr($alias, $pos);
153
			} else {
154
				foreach (static::$aliases[$root] as $name => $path) {
155 156 157
					if (strpos($alias . '/', $name . '/') === 0) {
						return $path . substr($alias, strlen($name));
					}
Qiang Xue committed
158
				}
Qiang Xue committed
159 160
			}
		}
161

Qiang Xue committed
162 163 164 165 166
		if ($throwException) {
			throw new InvalidParamException("Invalid path alias: $alias");
		} else {
			return false;
		}
Qiang Xue committed
167 168
	}

Qiang Xue committed
169 170 171 172 173 174 175 176 177 178 179 180
	/**
	 * 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);

181 182
		if (isset(static::$aliases[$root])) {
			if (is_string(static::$aliases[$root])) {
Qiang Xue committed
183 184
				return $root;
			} else {
185
				foreach (static::$aliases[$root] as $name => $path) {
Qiang Xue committed
186 187 188 189 190 191 192 193 194
					if (strpos($alias . '/', $name . '/') === 0) {
						return $name;
					}
				}
			}
		}
		return false;
	}

Qiang Xue committed
195
	/**
w  
Qiang Xue committed
196
	 * Registers a path alias.
m  
Qiang Xue committed
197
	 *
198 199
	 * 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
200
	 *
201 202
	 * A path alias must start with the character '@' so that it can be easily differentiated
	 * from non-alias paths.
m  
Qiang Xue committed
203
	 *
204 205 206 207 208 209 210 211 212 213
	 * 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
214 215 216 217
	 *
	 * - 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
218
	 *   actual path first by calling [[getAlias()]].
Qiang Xue committed
219
	 *
Qiang Xue committed
220
	 * @throws InvalidParamException if $path is an invalid alias.
221
	 * @see getAlias()
Qiang Xue committed
222
	 */
w  
Qiang Xue committed
223
	public static function setAlias($alias, $path)
Qiang Xue committed
224
	{
225
		if (strncmp($alias, '@', 1)) {
Qiang Xue committed
226
			$alias = '@' . $alias;
227 228 229 230 231
		}
		$pos = strpos($alias, '/');
		$root = $pos === false ? $alias : substr($alias, 0, $pos);
		if ($path !== null) {
			$path = strncmp($path, '@', 1) ? rtrim($path, '\\/') : static::getAlias($path);
232
			if (!isset(static::$aliases[$root])) {
Qiang Xue committed
233
				if ($pos === false) {
234
					static::$aliases[$root] = $path;
Qiang Xue committed
235
				} else {
236
					static::$aliases[$root] = [$alias => $path];
Qiang Xue committed
237
				}
238
			} elseif (is_string(static::$aliases[$root])) {
239
				if ($pos === false) {
240
					static::$aliases[$root] = $path;
241
				} else {
242
					static::$aliases[$root] = [
243
						$alias => $path,
244
						$root => static::$aliases[$root],
Alexander Makarov committed
245
					];
246 247
				}
			} else {
248 249
				static::$aliases[$root][$alias] = $path;
				krsort(static::$aliases[$root]);
250
			}
251 252 253
		} elseif (isset(static::$aliases[$root])) {
			if (is_array(static::$aliases[$root])) {
				unset(static::$aliases[$root][$alias]);
254
			} elseif ($pos === false) {
255
				unset(static::$aliases[$root]);
256
			}
m  
Qiang Xue committed
257
		}
Qiang Xue committed
258 259 260 261
	}

	/**
	 * Class autoload loader.
Qiang Xue committed
262 263
	 * 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
264 265 266 267 268 269 270 271 272
	 *
	 * 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`);
	 *
273 274 275
	 * 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.
	 *
276
	 * @param string $className the fully qualified class name without a leading backslash "\"
277
	 * @throws UnknownClassException if the class does not exist in the class file
Qiang Xue committed
278 279 280
	 */
	public static function autoload($className)
	{
281 282
		if (isset(static::$classMap[$className])) {
			$classFile = static::$classMap[$className];
283 284
			if ($classFile[0] === '@') {
				$classFile = static::getAlias($classFile);
Qiang Xue committed
285
			}
Qiang Xue committed
286
		} else {
Qiang Xue committed
287
			// follow PSR-0 to determine the class file
Qiang Xue committed
288 289
			if (($pos = strrpos($className, '\\')) !== false) {
				// namespaced class, e.g. yii\base\Component
Qiang Xue committed
290
				$path = str_replace('\\', '/', substr($className, 0, $pos + 1))
Qiang Xue committed
291 292
					. str_replace('_', '/', substr($className, $pos + 1)) . '.php';
			} else {
Qiang Xue committed
293
				$path = str_replace('_', '/', $className) . '.php';
w  
Qiang Xue committed
294
			}
Qiang Xue committed
295

296
			// try loading via path alias
297 298 299
			if (strpos($path, '/') === false) {
				return;
			} else {
300
				$classFile = static::getAlias('@' . $path, false);
301 302
				if ($classFile === false || !is_file($classFile)) {
					return;
Qiang Xue committed
303
				}
Qiang Xue committed
304
			}
w  
Qiang Xue committed
305
		}
306 307 308

		include($classFile);

309
		if (YII_DEBUG && !class_exists($className, false) && !interface_exists($className, false) && !trait_exists($className, false)) {
310 311
			throw new UnknownClassException("Unable to find '$className' in file: $classFile");
		}
Qiang Xue committed
312 313
	}

w  
Qiang Xue committed
314
	/**
Qiang Xue committed
315
	 * Creates a new object using the given configuration.
w  
Qiang Xue committed
316
	 *
Qiang Xue committed
317
	 * The configuration can be either a string or an array.
Qiang Xue committed
318 319
	 * 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
320 321 322
	 * the rest of the name-value pairs in the array will be used to initialize
	 * the corresponding object properties.
	 *
Qiang Xue committed
323 324
	 * Below are some usage examples:
	 *
w  
Qiang Xue committed
325
	 * ~~~
Qiang Xue committed
326
	 * $object = \Yii::createObject('app\components\GoogleMap');
Alexander Makarov committed
327
	 * $object = \Yii::createObject([
Qiang Xue committed
328
	 *     'class' => 'app\components\GoogleMap',
w  
Qiang Xue committed
329
	 *     'apiKey' => 'xyz',
Alexander Makarov committed
330
	 * ]);
w  
Qiang Xue committed
331 332
	 * ~~~
	 *
Qiang Xue committed
333 334 335 336
	 * This method can be used to create any object as long as the object's constructor is
	 * defined like the following:
	 *
	 * ~~~
Alexander Makarov committed
337
	 * public function __construct(..., $config = []) {
Qiang Xue committed
338 339 340 341 342
	 * }
	 * ~~~
	 *
	 * 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
343
	 *
Qiang Xue committed
344 345
	 * @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
346
	 * @return mixed the created object
Qiang Xue committed
347
	 * @throws InvalidConfigException if the configuration is invalid.
w  
Qiang Xue committed
348
	 */
Qiang Xue committed
349
	public static function createObject($config)
w  
Qiang Xue committed
350
	{
Alexander Makarov committed
351
		static $reflections = [];
Qiang Xue committed
352

w  
Qiang Xue committed
353
		if (is_string($config)) {
w  
Qiang Xue committed
354
			$class = $config;
Alexander Makarov committed
355
			$config = [];
Qiang Xue committed
356
		} elseif (isset($config['class'])) {
w  
Qiang Xue committed
357
			$class = $config['class'];
w  
Qiang Xue committed
358
			unset($config['class']);
Qiang Xue committed
359
		} else {
Qiang Xue committed
360
			throw new InvalidConfigException('Object configuration must be an array containing a "class" element.');
w  
Qiang Xue committed
361 362
		}

Qiang Xue committed
363 364
		$class = ltrim($class, '\\');

365 366
		if (isset(static::$objectConfig[$class])) {
			$config = array_merge(static::$objectConfig[$class], $config);
367 368
		}

Qiang Xue committed
369
		if (($n = func_num_args()) > 1) {
slavcodev committed
370
			/** @var \ReflectionClass $reflection */
Qiang Xue committed
371 372
			if (isset($reflections[$class])) {
				$reflection = $reflections[$class];
Qiang Xue committed
373
			} else {
Qiang Xue committed
374 375 376 377
				$reflection = $reflections[$class] = new \ReflectionClass($class);
			}
			$args = func_get_args();
			array_shift($args); // remove $config
378
			if (!empty($config)) {
Qiang Xue committed
379
				$args[] = $config;
Qiang Xue committed
380
			}
Qiang Xue committed
381
			return $reflection->newInstanceArgs($args);
Qiang Xue committed
382
		} else {
383
			return empty($config) ? new $class : new $class($config);
Qiang Xue committed
384
		}
w  
Qiang Xue committed
385 386
	}

Qiang Xue committed
387
	/**
w  
Qiang Xue committed
388 389 390 391 392
	 * 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
393
	 */
w  
Qiang Xue committed
394
	public static function trace($message, $category = 'application')
Qiang Xue committed
395
	{
w  
Qiang Xue committed
396
		if (YII_DEBUG) {
397
			static::$app->getLog()->log($message, Logger::LEVEL_TRACE, $category);
w  
Qiang Xue committed
398
		}
Qiang Xue committed
399 400 401
	}

	/**
w  
Qiang Xue committed
402 403 404 405 406
	 * 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
407
	 */
Qiang Xue committed
408
	public static function error($message, $category = 'application')
Qiang Xue committed
409
	{
410
		static::$app->getLog()->log($message, Logger::LEVEL_ERROR, $category);
w  
Qiang Xue committed
411 412 413 414 415 416 417 418 419
	}

	/**
	 * 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
420
	public static function warning($message, $category = 'application')
w  
Qiang Xue committed
421
	{
422
		static::$app->getLog()->log($message, Logger::LEVEL_WARNING, $category);
Qiang Xue committed
423 424 425
	}

	/**
w  
Qiang Xue committed
426 427 428 429 430 431
	 * 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
432
	public static function info($message, $category = 'application')
w  
Qiang Xue committed
433
	{
434
		static::$app->getLog()->log($message, Logger::LEVEL_INFO, $category);
w  
Qiang Xue committed
435 436 437 438 439 440 441 442 443
	}

	/**
	 * 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
444 445 446 447
	 * // some code to be profiled
	 *     \Yii::beginProfile('block2');
	 *     // some other code to be profiled
	 *     \Yii::endProfile('block2');
w  
Qiang Xue committed
448 449
	 * \Yii::endProfile('block1');
	 * ~~~
Qiang Xue committed
450 451
	 * @param string $token token for the code block
	 * @param string $category the category of this log message
452
	 * @see endProfile()
Qiang Xue committed
453
	 */
Qiang Xue committed
454
	public static function beginProfile($token, $category = 'application')
Qiang Xue committed
455
	{
456
		static::$app->getLog()->log($token, Logger::LEVEL_PROFILE_BEGIN, $category);
Qiang Xue committed
457 458 459 460
	}

	/**
	 * Marks the end of a code block for profiling.
w  
Qiang Xue committed
461
	 * This has to be matched with a previous call to [[beginProfile]] with the same category name.
Qiang Xue committed
462 463
	 * @param string $token token for the code block
	 * @param string $category the category of this log message
464
	 * @see beginProfile()
Qiang Xue committed
465
	 */
Qiang Xue committed
466
	public static function endProfile($token, $category = 'application')
Qiang Xue committed
467
	{
468
		static::$app->getLog()->log($token, Logger::LEVEL_PROFILE_END, $category);
Qiang Xue committed
469 470 471
	}

	/**
w  
Qiang Xue committed
472 473
	 * 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
474 475 476
	 */
	public static function powered()
	{
Qiang Xue committed
477
		return 'Powered by <a href="http://www.yiiframework.com/" rel="external">Yii Framework</a>';
Qiang Xue committed
478 479 480 481
	}

	/**
	 * Translates a message to the specified language.
Qiang Xue committed
482
	 *
483 484 485
	 * 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
486 487 488 489 490 491 492 493 494 495 496 497
	 *
	 * 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]]
	 *
498
	 * @param string $category the message category.
Qiang Xue committed
499 500
	 * @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.
501
	 * @param string $language the language code (e.g. `en-US`, `en`). If this is null, the current
Qiang Xue committed
502 503
	 * [[\yii\base\Application::language|application language]] will be used.
	 * @return string the translated message.
Qiang Xue committed
504
	 */
Alexander Makarov committed
505
	public static function t($category, $message, $params = [], $language = null)
Qiang Xue committed
506
	{
507 508
		if (static::$app !== null) {
			return static::$app->getI18n()->translate($category, $message, $params, $language ?: static::$app->language);
Qiang Xue committed
509
		} else {
510
			$p = [];
511
			foreach ((array) $params as $name => $value) {
512 513 514
				$p['{' . $name . '}'] = $value;
			}
			return ($p === []) ? $message : strtr($message, $p);
Qiang Xue committed
515
		}
Qiang Xue committed
516
	}
Qiang Xue committed
517 518 519 520 521

	/**
	 * 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.
522
	 * @return object the object itself
Qiang Xue committed
523 524 525 526 527 528
	 */
	public static function configure($object, $properties)
	{
		foreach ($properties as $name => $value) {
			$object->$name = $value;
		}
529
		return $object;
Qiang Xue committed
530
	}
531 532 533 534 535 536 537 538 539 540 541 542 543

	/**
	 * 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
544
}