/**
* Loads the given class or interface.
*
* @param string $class The name of the class
*
* @return boolean|null True if loaded, null otherwise
*
* @since 3.4
*/
public function loadClass($class)
{
if ($result = $this->loader->loadClass($class)) {
JLoader::applyAliasFor($class);
}
return $result;
}
/**
* @param string $class
*
* @return bool
*/
public function loadClass($class)
{
if (strpos(ltrim($class, '\\'), __NAMESPACE__) === 0) {
return $this->composer->loadClass($class);
} elseif ($file = $this->composer->findFile($class)) {
\Composer\Autoload\includeFile('php://filter/read=influence.reader/resource=' . $file);
return true;
}
return false;
}
/**
* Check if a required class exists, and if not, try to load it via composer and recheck.
* Can not use directly autoloader with class_exists. Sometimes it's behavior is non consistent
* with spl_autoload_register.
*
* @param string $className
* @return bool
*/
private function testClassExists($className)
{
if (class_exists($className, false)) {
return true;
}
return $this->composerInstance->loadClass($className) && class_exists($className, false);
}
/**
* Check that the auto loading information is correct.
*
* @return bool
*/
public function tryLoadAllClasses()
{
$result = true;
// Trick Contao 2.11 into believing it is installed.
if (!defined('TL_ROOT')) {
define('TL_ROOT', '/tmp');
}
// Try hacking via Contao autoloader.
spl_autoload_register(function ($class) {
if (substr($class, 0, 7) !== 'Contao\\') {
spl_autoload_call('Contao\\' . $class);
if (class_exists('Contao\\' . $class, false) && !class_exists($class, false)) {
class_alias('Contao\\' . $class, $class);
}
}
});
// Now try to autoload all classes.
foreach ($this->classMap as $class => $file) {
if (!$this->isLoaded($class)) {
try {
if (!$this->loader->loadClass($class)) {
$this->output->writeln(sprintf('<error>The autoloader could not load %s (should be found from file %s).</error>', $class, $file));
$result = false;
}
} catch (\ErrorException $exception) {
$this->output->writeln(sprintf('<error>ERROR loading class %s: "%s".</error>', $class, $exception->getMessage()));
$result = false;
}
}
}
return $result;
}
/**
* Load class with the option to respect case insensitivity
*
* @param string $className
* @return bool|null
*/
public function loadClass($className)
{
$classFound = $this->composerClassLoader->loadClass($className);
if (!$classFound && !$this->caseSensitiveClassLoading) {
$classFound = $this->composerClassLoader->loadClass(strtolower($className));
}
return $classFound;
}
public function loadClass($class)
{
/* @var ClassLoader $loader */
if ($this->mainLoader->loadClass($class)) {
return true;
}
return false;
}
/**
* Tests regular PSR-0 and PSR-4 class loading.
*
* @dataProvider getLoadClassTests
*
* @param string $class The fully-qualified class name to test, without preceding namespace separator.
*/
public function testLoadClass($class)
{
$loader = new ClassLoader();
$loader->add('Namespaced\\', __DIR__ . '/Fixtures');
$loader->add('Pearlike_', __DIR__ . '/Fixtures');
$loader->addPsr4('ShinyVendor\\ShinyPackage\\', __DIR__ . '/Fixtures');
$loader->loadClass($class);
$this->assertTrue(class_exists($class, false), "->loadClass() loads '{$class}'");
}
/**
* Load class with the option to respect case insensitivity
*
* @param string $className
* @return bool|null
*/
public function loadClass($className)
{
if (!$this->caseSensitiveClassLoading) {
$lowerCasedClassName = strtolower($className);
if ($this->composerClassLoader->findFile($lowerCasedClassName)) {
return $this->composerClassLoader->loadClass($lowerCasedClassName);
}
}
return $this->composerClassLoader->loadClass($className);
}
/**
* Loads the given class or interface and invokes static constructor on it
*
* @param string $className The name of the class
* @return bool|null True if loaded, null otherwise
*/
public function loadClass($className)
{
$result = $this->loader->loadClass($className);
if ($result === true) {
//class loaded successfully
$this->callConstruct($className);
return true;
}
return null;
}
/**
* To load the factory of the stated class and check if it's implementing the good interface.
*
* @param string $factoryClassName
*
* @return bool
*/
private function loadFactory(string &$factoryClassName) : bool
{
if (!isset($this->factoryAvailabilityList[$factoryClassName])) {
if (true === \class_exists($factoryClassName, false) || true === $this->composerInstance->loadClass($factoryClassName)) {
$reflectionClassInstance = new \ReflectionClass($factoryClassName);
$this->factoryAvailabilityList[$factoryClassName] = $reflectionClassInstance->implementsInterface(FactoryInterface::class);
} else {
$this->factoryAvailabilityList[$factoryClassName] = false;
}
}
return $this->factoryAvailabilityList[$factoryClassName];
}
/**
* Tests regular PSR-0 and PSR-4 class loading.
*
* @dataProvider getLoadClassTests
*
* @param string $class The fully-qualified class name to test, without preceding namespace separator.
* @param bool $prependSeparator Whether to call ->loadClass() with a class name with preceding
* namespace separator, as it happens in PHP 5.3.0 - 5.3.2. See https://bugs.php.net/50731
*/
public function testLoadClass($class, $prependSeparator = FALSE)
{
$loader = new ClassLoader();
$loader->add('Namespaced\\', __DIR__ . '/Fixtures');
$loader->add('Pearlike_', __DIR__ . '/Fixtures');
$loader->addPsr4('ShinyVendor\\ShinyPackage\\', __DIR__ . '/Fixtures');
if ($prependSeparator) {
$prepend = '\\';
$message = "->loadClass() loads '{$class}'.";
} else {
$prepend = '';
$message = "->loadClass() loads '\\{$class}', as required in PHP 5.3.0 - 5.3.2.";
}
$loader->loadClass($prepend . $class);
$this->assertTrue(class_exists($class, false), $message);
}
/**
* {@inheritdoc}
* @codeCoverageIgnore
*/
public function loadClass($className)
{
return $this->autoloader->loadClass($className) === true;
}
