commit version 22.12.12447

libs/flight2/core/Loader.php

@@ -0,0 +1,233 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * Flight: An extensible micro-framework.
+ *
+ * @copyright   Copyright (c) 2011, Mike Cao <mike@mikecao.com>
+ * @license     MIT, http://flightphp.com/license
+ */
+
+namespace flight\core;
+
+use Exception;
+use ReflectionClass;
+use ReflectionException;
+
+/**
+ * The Loader class is responsible for loading objects. It maintains
+ * a list of reusable class instances and can generate a new class
+ * instances with custom initialization parameters. It also performs
+ * class autoloading.
+ */
+class Loader
+{
+    /**
+     * Registered classes.
+     */
+    protected array $classes = [];
+
+    /**
+     * Class instances.
+     */
+    protected array $instances = [];
+
+    /**
+     * Autoload directories.
+     */
+    protected static array $dirs = [];
+
+    /**
+     * Registers a class.
+     *
+     * @param string          $name     Registry name
+     * @param callable|string $class    Class name or function to instantiate class
+     * @param array           $params   Class initialization parameters
+     * @param callable|null   $callback $callback Function to call after object instantiation
+     */
+    public function register(string $name, $class, array $params = [], ?callable $callback = null): void
+    {
+        unset($this->instances[$name]);
+
+        $this->classes[$name] = [$class, $params, $callback];
+    }
+
+    /**
+     * Unregisters a class.
+     *
+     * @param string $name Registry name
+     */
+    public function unregister(string $name): void
+    {
+        unset($this->classes[$name]);
+    }
+
+    /**
+     * Loads a registered class.
+     *
+     * @param string $name   Method name
+     * @param bool   $shared Shared instance
+     *
+     * @throws Exception
+     *
+     * @return object Class instance
+     */
+    public function load(string $name, bool $shared = true): ?object
+    {
+        $obj = null;
+
+        if (isset($this->classes[$name])) {
+            [$class, $params, $callback] = $this->classes[$name];
+
+            $exists = isset($this->instances[$name]);
+
+            if ($shared) {
+                $obj = ($exists) ?
+                    $this->getInstance($name) :
+                    $this->newInstance($class, $params);
+
+                if (!$exists) {
+                    $this->instances[$name] = $obj;
+                }
+            } else {
+                $obj = $this->newInstance($class, $params);
+            }
+
+            if ($callback && (!$shared || !$exists)) {
+                $ref = [&$obj];
+                \call_user_func_array($callback, $ref);
+            }
+        }
+
+        return $obj;
+    }
+
+    /**
+     * Gets a single instance of a class.
+     *
+     * @param string $name Instance name
+     *
+     * @return object Class instance
+     */
+    public function getInstance(string $name): ?object
+    {
+        return $this->instances[$name] ?? null;
+    }
+
+    /**
+     * Gets a new instance of a class.
+     *
+     * @param callable|string $class  Class name or callback function to instantiate class
+     * @param array           $params Class initialization parameters
+     *
+     * @throws Exception
+     *
+     * @return object Class instance
+     */
+    public function newInstance($class, array $params = []): object
+    {
+        if (\is_callable($class)) {
+            return \call_user_func_array($class, $params);
+        }
+
+        switch (\count($params)) {
+            case 0:
+                return new $class();
+            case 1:
+                return new $class($params[0]);
+            case 2:
+                return new $class($params[0], $params[1]);
+            case 3:
+                return new $class($params[0], $params[1], $params[2]);
+            case 4:
+                return new $class($params[0], $params[1], $params[2], $params[3]);
+            case 5:
+                return new $class($params[0], $params[1], $params[2], $params[3], $params[4]);
+            default:
+                try {
+                    $refClass = new ReflectionClass($class);
+
+                    return $refClass->newInstanceArgs($params);
+                } catch (ReflectionException $e) {
+                    throw new Exception("Cannot instantiate {$class}", 0, $e);
+                }
+        }
+    }
+
+    /**
+     * @param string $name Registry name
+     *
+     * @return mixed Class information or null if not registered
+     */
+    public function get(string $name)
+    {
+        return $this->classes[$name] ?? null;
+    }
+
+    /**
+     * Resets the object to the initial state.
+     */
+    public function reset(): void
+    {
+        $this->classes = [];
+        $this->instances = [];
+    }
+
+    // Autoloading Functions
+
+    /**
+     * Starts/stops autoloader.
+     *
+     * @param bool  $enabled Enable/disable autoloading
+     * @param mixed $dirs    Autoload directories
+     */
+    public static function autoload(bool $enabled = true, $dirs = []): void
+    {
+        if ($enabled) {
+            spl_autoload_register([__CLASS__, 'loadClass']);
+        } else {
+            spl_autoload_unregister([__CLASS__, 'loadClass']);
+        }
+
+        if (!empty($dirs)) {
+            self::addDirectory($dirs);
+        }
+    }
+
+    /**
+     * Autoloads classes.
+     *
+     * @param string $class Class name
+     */
+    public static function loadClass(string $class): void
+    {
+        $class_file = str_replace(['\\', '_'], '/', $class) . '.php';
+
+        foreach (self::$dirs as $dir) {
+            $file = $dir . '/' . $class_file;
+            if (file_exists($file)) {
+                require $file;
+
+                return;
+            }
+        }
+    }
+
+    /**
+     * Adds a directory for autoloading classes.
+     *
+     * @param mixed $dir Directory path
+     */
+    public static function addDirectory($dir): void
+    {
+        if (\is_array($dir) || \is_object($dir)) {
+            foreach ($dir as $value) {
+                self::addDirectory($value);
+            }
+        } elseif (\is_string($dir)) {
+            if (!\in_array($dir, self::$dirs, true)) {
+                self::$dirs[] = $dir;
+            }
+        }
+    }
+}