<h2>File Contents: /home/planet5/www/wp-content/plugins/wordpress-seo-premium/vendor/composer/ClassLoader52.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/www/wp-content/plugins/wordpress-seo-premium/vendor/composer/ClassLoader52.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php
/*
 * Copyright (c) 2013, Christoph Mewes, http://www.xrstf.de
 *
 * This file is released under the terms of the MIT license. You can find the
 * complete text in the attached LICENSE file or online at:
 *
 * http://www.opensource.org/licenses/mit-license.php
 *
 * --------------------------------------------------------------------------
 *
 * 99% of this is copied as-is from the original Composer source code and is
 * released under MIT license as well. Copyright goes to:
 *
 * - Fabien Potencier &lt;fabien@symfony.com&gt;
 * - Jordi Boggiano &lt;j.boggiano@seld.be&gt;
 */

class xrstf_Composer52_ClassLoader {
	private $prefixes              = array();
	private $fallbackDirs          = array();
	private $useIncludePath        = false;
	private $classMap              = array();
	private $classMapAuthoratative = false;
	private $allowUnderscore       = false;

	/**
	 * @param boolean $flag  true to allow class names with a leading underscore, false to disable
	 */
	public function setAllowUnderscore($flag) {
		$this-&gt;allowUnderscore = (boolean) $flag;
	}

	/**
	 * @return array
	 */
	public function getPrefixes() {
		return $this-&gt;prefixes;
	}

	/**
	 * Turns off searching the prefix and fallback directories for classes
	 * that have not been registered with the class map.
	 *
	 * @param bool $classMapAuthoratative
	 */
	public function setClassMapAuthoritative($classMapAuthoratative) {
		$this-&gt;classMapAuthoratative = $classMapAuthoratative;
	}

	/**
	 * Should class lookup fail if not found in the current class map?
	 *
	 * @return bool
	 */
	public function getClassMapAuthoratative() {
		return $this-&gt;classMapAuthoratative;
	}

	/**
	 * @return array
	 */
	public function getFallbackDirs() {
		return $this-&gt;fallbackDirs;
	}

	/**
	 * @return array
	 */
	public function getClassMap() {
		return $this-&gt;classMap;
	}

	/**
	 * @param array $classMap  class to filename map
	 */
	public function addClassMap(array $classMap) {
		if ($this-&gt;classMap) {
			$this-&gt;classMap = array_merge($this-&gt;classMap, $classMap);
		}
		else {
			$this-&gt;classMap = $classMap;
		}
	}

	/**
	 * Registers a set of classes, merging with any others previously set.
	 *
	 * @param string       $prefix   the classes prefix
	 * @param array|string $paths    the location(s) of the classes
	 * @param bool         $prepend  prepend the location(s)
	 */
	public function add($prefix, $paths, $prepend = false) {
		if (!$prefix) {
			if ($prepend) {
				$this-&gt;fallbackDirs = array_merge(
					(array) $paths,
					$this-&gt;fallbackDirs
				);
			}
			else {
				$this-&gt;fallbackDirs = array_merge(
					$this-&gt;fallbackDirs,
					(array) $paths
				);
			}

			return;
		}

		if (!isset($this-&gt;prefixes[$prefix])) {
			$this-&gt;prefixes[$prefix] = (array) $paths;
			return;
		}

		if ($prepend) {
			$this-&gt;prefixes[$prefix] = array_merge(
				(array) $paths,
				$this-&gt;prefixes[$prefix]
			);
		}
		else {
			$this-&gt;prefixes[$prefix] = array_merge(
				$this-&gt;prefixes[$prefix],
				(array) $paths
			);
		}
	}

	/**
	 * Registers a set of classes, replacing any others previously set.
	 *
	 * @param string       $prefix  the classes prefix
	 * @param array|string $paths   the location(s) of the classes
	 */
	public function set($prefix, $paths) {
		if (!$prefix) {
			$this-&gt;fallbackDirs = (array) $paths;
			return;
		}

		$this-&gt;prefixes[$prefix] = (array) $paths;
	}

	/**
	 * Turns on searching the include path for class files.
	 *
	 * @param bool $useIncludePath
	 */
	public function setUseIncludePath($useIncludePath) {
		$this-&gt;useIncludePath = $useIncludePath;
	}

	/**
	 * Can be used to check if the autoloader uses the include path to check
	 * for classes.
	 *
	 * @return bool
	 */
	public function getUseIncludePath() {
		return $this-&gt;useIncludePath;
	}

	/**
	 * Registers this instance as an autoloader.
	 */
	public function register() {
		spl_autoload_register(array($this, &#039;loadClass&#039;), true);
	}

	/**
	 * Unregisters this instance as an autoloader.
	 */
	public function unregister() {
		spl_autoload_unregister(array($this, &#039;loadClass&#039;));
	}

	/**
	 * Loads the given class or interface.
	 *
	 * @param  string $class  the name of the class
	 * @return bool|null      true, if loaded
	 */
	public function loadClass($class) {
		if ($file = $this-&gt;findFile($class)) {
			include $file;
			return true;
		}
	}

	/**
	 * Finds the path to the file where the class is defined.
	 *
	 * @param  string $class  the name of the class
	 * @return string|null    the path, if found
	 */
	public function findFile($class) {
		if (&#039;\\&#039; === $class[0]) {
			$class = substr($class, 1);
		}

		if (isset($this-&gt;classMap[$class])) {
			return $this-&gt;classMap[$class];
		}
		elseif ($this-&gt;classMapAuthoratative) {
			return false;
		}

		$classPath = $this-&gt;getClassPath($class);

		foreach ($this-&gt;prefixes as $prefix =&gt; $dirs) {
			if (0 === strpos($class, $prefix)) {
				foreach ($dirs as $dir) {
					if (file_exists($dir.DIRECTORY_SEPARATOR.$classPath)) {
						return $dir.DIRECTORY_SEPARATOR.$classPath;
					}
				}
			}
		}

		foreach ($this-&gt;fallbackDirs as $dir) {
			if (file_exists($dir.DIRECTORY_SEPARATOR.$classPath)) {
				return $dir.DIRECTORY_SEPARATOR.$classPath;
			}
		}

		if ($this-&gt;useIncludePath &amp;&amp; $file = self::resolveIncludePath($classPath)) {
			return $file;
		}

		return $this-&gt;classMap[$class] = false;
	}

	private function getClassPath($class) {
		if (false !== $pos = strrpos($class, &#039;\\&#039;)) {
			// namespaced class name
			$classPath = str_replace(&#039;\\&#039;, DIRECTORY_SEPARATOR, substr($class, 0, $pos)).DIRECTORY_SEPARATOR;
			$className = substr($class, $pos + 1);
		}
		else {
			// PEAR-like class name
			$classPath = null;
			$className = $class;
		}

		$className = str_replace(&#039;_&#039;, DIRECTORY_SEPARATOR, $className);

		// restore the prefix
		if ($this-&gt;allowUnderscore &amp;&amp; DIRECTORY_SEPARATOR === $className[0]) {
			$className[0] = &#039;_&#039;;
		}

		$classPath .= $className.&#039;.php&#039;;

		return $classPath;
	}

	public static function resolveIncludePath($classPath) {
		$paths = explode(PATH_SEPARATOR, get_include_path());

		foreach ($paths as $path) {
			$path = rtrim($path, &#039;/\\&#039;);

			if ($file = file_exists($path.DIRECTORY_SEPARATOR.$file)) {
				return $file;
			}
		}

		return false;
	}
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fwww%2Fwp-content%2Fplugins%2Fwordpress-seo-premium%2Fvendor%2Fcomposer'>⬅ Back to Directory</a>