lithium\core\Libraries::instance()

public static method

Uses service location (i.e. Libraries::locate()) to look up a named class of a particular type, and creates an instance of it, and passes an array of parameters to the constructor.

If the given class can't be found, an exception is thrown.

Parameters

  • string $type

    The type of class as defined by Libraries::$_paths.
  • string $name

    The un-namespaced name of the class to instantiate.
  • array $options

    An array of constructor parameters to pass to the class.

Returns

object

If the class is found, returns an instance of it, otherwise throws an exception.

Filter

This method can be filtered.

Source

	public static function instance($type, $name, array $options = array()) {
		$params = compact('type', 'name', 'options');
		$_paths =& static::$_paths;

		$implementation = function($self, $params) use (&$_paths) {
			$name = $params['name'];
			$type = $params['type'];

			if (!$name && !$type) {
				$message = "Invalid class lookup: `\$name` and `\$type` are empty.";
				throw new ClassNotFoundException($message);
			}
			if (!is_string($type) && $type !== null && !isset($_paths[$type])) {
				throw new ClassNotFoundException("Invalid class type `{$type}`.");
			}
			if (!$class = $self::locate($type, $name)) {
				throw new ClassNotFoundException("Class `{$name}` of type `{$type}` not found.");
			}
			if (is_object($class)) {
				return $class;
			}
			if (!(is_string($class) && class_exists($class))) {
				throw new ClassNotFoundException("Class `{$name}` of type `{$type}` not defined.");
			}
			return new $class($params['options']);
		};
		if (!isset(static::$_methodFilters[__FUNCTION__])) {
			return $implementation(get_called_class(), $params);
		}
		$class = get_called_class();
		$method = __FUNCTION__;
		$data = array_merge(static::$_methodFilters[__FUNCTION__], array($implementation));
		return Filters::run($class, $params, compact('data', 'class', 'method'));
	}