ÿØÿà JFIF    ÿÛ „  ( %!1"%)+...383-7(-.+  -%%--------+------------/----------------------------ÿÀ  ¶" ÿÄ     ÿÄ @    !1AQaq‘¡"±ÁÑð2’BRráS‚ñ3b¢CT²Ò #cÿÄ    ÿÄ '   1!AQ2a"‘±#ÿÚ   ? ò(/p‘—–¢·,M|¯G»R£üešT. ôŸEoCFñ‡ 4ÔkåóxR|µÁ¨ÓDà!Ç´µ˜‡p ÍQ‹§!þž^õWsŒy  åÁ§$á«%ºq˜™JyyË0y«^Ϗ -3ÃÏËÈ£Æ\P’ä„s&•‹Üs üô'àWt¹pñCp$bÚF`·7.^)¾!)ÒÙ˜–ÅÏš^h¾ø³·ìe±ŒaeÖ—Í,e=B}Jéߦ$$½—šÙÜCC¯¶è8β–Åkèwx LÉngT±æ¹£Ócœ¿Í/©Éÿ ‰ÚCÒ­mq;Tt¶–}0"zÖPcd1š­¤tˆ„ÐÓâqú[™öUCŠ2޿د­É(¸ßúçšmW,Ò ºf‹Ån™ÄLêÁ8üÁkÁ€L¥ÍuJ1œôrÂSŒÓöt!7EUíïb)AËi¬â-ÙHk8òÁiXYwÅ)O^"ÇØriÛô{»wRUKÙÏÚlÓ¬€‚’שT ] ªb—ÊîKC^×M“xùäñz¬zJ× {4[¹M'IÆeH1LCWÕ]œûº WDæà°OÅ‚¹c²ÞuA–rL`HšpCez‡V’— Ž‚Ë„–ñ­'µR0ÕÖ=À:±G»C\nÆÉ5*¢ †3šhQ4ýÒi$Õ1"Ü]¢p-q3zcQ$ªö¨¥æf›‘»´ÝÚHá„e²JÇ–iÊ:·à¬Øc5Åk»Laª*wi [0Ówk ¦a¦0Õ²ÅÅ‚T¸’³q:Æ<¹ú Ò˜Æ}2VE•Ð€p¡Ô3Úº …h³^LJºçì¥Ánó|˜ÖˆÎˆ+« ¦dø‘Mº–d\ªDðÛ„Ì×LÝ——Ð9Ç|•FèçVm™¨€™3õS–9Äå¢<̉Ìm¢±`·º˜&Z²ž Ë®D«¶»6™‰©­HÈ Àá«h­i³04æ’hxœi3ï¨(ÓL·†‹¶ËpŒ ƒÜÒ? :õdsÀ –3æÓ·Üjâ¬9—]8n¼&]I F£¼…ì–—Œ0v°LǐÅfÛ2TÖ’aµ˜N@ÖBSÏ^à´4-±°b×nÈÈœÆD=KdŒø…ÄÈK,›ÖR§fjü$^ÔÎ!„6^ s:Üun\ôkCÞò÷<—Lúl Í›G¹ÀPá¼Nc¡šÒ…ÙWͳœ±vÊáЄ×9‹P‰cEØ‘™›µŸP<×g1 º©Ø¬wiÁ^l5× I/';Ë+´Z‡ÓÄFÕp[Èð’ HÄ ó 9¬Dl4“é±Ï”V=^Hð;žLädÉa‚°Ë,#/Ž~²BÔÛ QãñQtIeórVB,ÏÂf‹4#Îœc‹É3ZIÖ Œ¢¥·üxa‡Ãçè„jŠ[5 Ä!U?,3žÎ×…ðdÓ÷háŠA‰ìÄ4÷ÃÜZÃE{‰®+W\ZÍE[‰»µk»MÝ­`¢©†˜ÃV‹-f¢¡†¢a«eŠ%«Y¨©q%jâd,Ôq`) ¤¦…šˆ ¦E>0Ùb²t–Ÿ  ÷jsÏ‚Ò’KÈcø(é›;k(’#ôŒQ ™C> õ³M9óºÆµ¤çâ;uÀ)5>RÔ¸fÓ~Ȧ—’-$fe«"FâUˆÊwµPÏu w+"åÉó¨6s™Û9(À¨ù©hE°½†n`m~“@©›p!Vkhµ Á1šbEqqÊ@ºèl›2 –Yã%‘‚hÛ{a¶‡ÅÞM²¬çL34®Çl]®‹ŽØŒm'RÜe35æöˆ­Á­ cP9šeÁköo´L³Ì=p8]”‡B¶,šº|ɏdzXˆØk*ÇÚ{#ñ‰pã(€¶‡9ý'šÜ³½¯kƒ†Â’ëSOƒ•Å®H6+a¢µˆ‹Y¨b˜b+XˆÖ!°u!¢"µˆˆn2ˆ Å0Ä`Å Ô®c(ÓÜGº•Ä»Œ âWî%q.áÐÄ÷î%umÍ£+ÜQ,Vn¦-GphU¸¢X­&,Gt ·K¢ÅÅ·¥RÄÊÉbKn N­R2g$VµÕó Qr#–ÓZUÏð0ÎtÙÀœz ëöo“Îk¯n„T°"SÞ+³/…€½"ižãO%Í%&Δâ‘ËØ´IˆÓ°Ë‰ÞM3.™yçÁzit›`4C`k¢¼á!álÄï sÂ[×!¤l¾æo"ƒIÔ'@ªu)3›ô®“@Z à¾] üœ'‡4¸PÞkÁ-qÄH‰ÓÍBd´ÿ —¹°ÄA&ÊUC„öz‚‚RæŠtf¬>˜ÑidšEçÑL÷áý¡V±h§­c¿¥¨ƒ@g¼…Ýö^ÞËc.ž„æ“I[ ª+·zÐÒÚ,½Ð»¶€C›7jk$๖€Ž¾ÅÙpp¶ÍþéΤ ½ØÎŒq ñpæžÅ¥#Øâ49ÃÂK^MYV“,¶Éz_òæ:…;Õ«¦I3âJ£¤û5$7Èxün\â]Êe¯(Ÿ&Ž‹¶2<6Ćf× æ¢ƱqWı[(ÙÂŽç‚T7¨@ÈÉÍß‚ïÙ"&3TYlGŽ†)†#5ŠA©^T2ÆÁ†)©†©†¤yGXÁ†©"†)©¼ÅV WS†#©]R–r‹q5ÕbâWþBh¯u+ªÅÄ×ü„nÑ^êkªÁj‰jeœWˆÕÕ`µDµ2Ì+Ä µDµµ5Ô{¤Þ0RF’H÷AÛ<ÊÁ§ ƈæ0Ñ£ê4 öÚµ[¬/1²€â<-¬šö²r×0o×w ´xÐÒË„ g01¬„åEM蛇Ã\6µE›‘fÙO k÷CºnÓ1`iîÒ² áÂ!ÑLÄÿ ³¬\õ*:M=Ç»c‹2[‰ØsÕLò\ŒK L^™üÄN\¶#» Ç\……ßïIœÉ$¸ÎñÍ®ÔHÇ Ûí/´>Li”„†g^$ 7NÍÑÑ2M2ªNg=k½Ð}Ÿl6‡ —JWˆ”ÞéT·+µ¦üÂFè¢Vs6ýÆ4»2+2IÝ9ô9®ÇGÙÇ1+Ä8;*Õ§ž½D*îÑWÚçá3Ma¤·ˆ¥t}š²Ü…Q+Æüµ8HíS”üxGéÁˆ¦Ël„éÈ 5 µÄƒ6äÜ(kIš¯S†fÖ&¸®×v|Äyˆ*禌Éù@7-®Ä[]ÎÖ¿ê`º…=:…žJVnݳvðÖKE¼‚ »mà ÷f®:Ë ™–4rð¡4` ܹçž~‹C=œ…¾Ïj|VDtK.ƒ"9 Ï ­–éXá³6WÒïIL-Ї Ç home/smkb8269/public_html/lms.smk-almanshuriyah.sch.id/cache/classes/factory.php000064400000064033152266626640023566 0ustar00. namespace core_cache; use core\exception\coding_exception; use cache_config_testing; use cache_phpunit_factory; /** * The cache factory class. * * This factory class is important because it stores instances of objects used by the cache API and returns them upon requests. * This allows us to both reuse objects saving on overhead, and gives us an easy place to "reset" the cache API in situations that * we need such as unit testing. * * @copyright 2012 Sam Hemelryk * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later * @package core_cache */ class factory { /** The cache has not been initialised yet. */ const STATE_UNINITIALISED = 0; /** The cache is in the process of initialising itself. */ const STATE_INITIALISING = 1; /** The cache is in the process of saving its configuration file. */ const STATE_SAVING = 2; /** The cache is ready to use. */ const STATE_READY = 3; /** The cache is currently updating itself */ const STATE_UPDATING = 4; /** The cache encountered an error while initialising. */ const STATE_ERROR_INITIALISING = 9; /** The cache has been disabled. */ const STATE_DISABLED = 10; /** The cache stores have been disabled */ const STATE_STORES_DISABLED = 11; /** * An instance of the factory class created upon the first request. * @var factory */ protected static $instance; /** * An array containing caches created for definitions * @var array */ protected $cachesfromdefinitions = []; /** * Array of caches created by parameters, ad-hoc definitions will have been used. * @var array */ protected $cachesfromparams = []; /** * An array of stores organised by definitions. * @var array */ protected $definitionstores = []; /** * An array of instantiated stores. * @var array */ protected $stores = []; /** * An array of configuration instances * @var array */ protected $configs = []; /** * An array of initialised definitions * @var array */ protected $definitions = []; /** * An array of lock plugins. * @var array */ protected $lockplugins = []; /** * The current state of the cache API. * @var int */ protected $state = 0; /** * The current cache display helper. * @var core_cache\local\administration_display_helper */ protected static $displayhelper = null; /** * Returns an instance of the factory class. * * @param bool $forcereload If set to true a new factory instance will be created and used. * @return factory */ public static function instance($forcereload = false) { global $CFG; if ($forcereload || self::$instance === null) { // Initialise a new factory to facilitate our needs. if (defined('CACHE_DISABLE_ALL') && CACHE_DISABLE_ALL !== false) { // The cache has been disabled. Load disabledlib and start using the factory designed to handle this // situation. It will use disabled alternatives where available. self::$instance = new disabled_factory(); } else if ((defined('PHPUNIT_TEST') && PHPUNIT_TEST) || defined('BEHAT_SITE_RUNNING')) { // We're using the test factory. require_once($CFG->dirroot . '/cache/tests/fixtures/lib.php'); self::$instance = new cache_phpunit_factory(); if (defined('CACHE_DISABLE_STORES') && CACHE_DISABLE_STORES !== false) { // The cache stores have been disabled. self::$instance->set_state(self::STATE_STORES_DISABLED); } } else if (!empty($CFG->alternative_cache_factory_class)) { $factoryclass = $CFG->alternative_cache_factory_class; self::$instance = new $factoryclass(); } else { // We're using the regular factory. self::$instance = new factory(); if (defined('CACHE_DISABLE_STORES') && CACHE_DISABLE_STORES !== false) { // The cache stores have been disabled. self::$instance->set_state(self::STATE_STORES_DISABLED); } } } return self::$instance; } /** * Protected constructor, please use the static instance method. */ protected function __construct() { // Nothing to do here. } /** * Resets the arrays containing instantiated caches, stores, and config instances. */ public static function reset() { $factory = self::instance(); $factory->reset_cache_instances(); $factory->configs = []; $factory->definitions = []; $factory->definitionstores = []; $factory->lockplugins = []; // MUST be null in order to force its regeneration. // Reset the state to uninitialised. $factory->state = self::STATE_UNINITIALISED; } /** * Resets the stores, clearing the array of created stores. * * Cache objects still held onto by the code that initialised them will remain as is * however all future requests for a cache/store will lead to a new instance being re-initialised. */ public function reset_cache_instances() { $this->cachesfromdefinitions = []; $this->cachesfromparams = []; $this->stores = []; } /** * Creates a cache object given the parameters for a definition. * * If a cache has already been created for the given definition then that cache instance will be returned. * * @param string $component * @param string $area * @param array $identifiers * @param string $unused Used to be data source aggregate however that was removed and this is now unused. * @return application_cache|session_cache|request_cache */ public function create_cache_from_definition($component, $area, array $identifiers = [], $unused = null) { $identifierstring = empty($identifiers) ? '' : '/' . http_build_query($identifiers); $definitionname = $component . '/' . $area . $identifierstring; if (isset($this->cachesfromdefinitions[$definitionname])) { $cache = $this->cachesfromdefinitions[$definitionname]; return $cache; } $definition = $this->create_definition($component, $area); // Identifiers are cached as part of the cache creation, so we store a cloned version of the cache. $cacheddefinition = clone($definition); $cacheddefinition->set_identifiers($identifiers); $cache = $this->create_cache($cacheddefinition); // Loaders are always held onto to speed up subsequent requests. $this->cachesfromdefinitions[$definitionname] = $cache; return $cache; } /** * Creates an ad-hoc cache from the given param. * * If a cache has already been created using the same params then that cache instance will be returned. * * @param int $mode * @param string $component * @param string $area * @param array $identifiers * @param array $options An array of options, available options are: * - simplekeys : Set to true if the keys you will use are a-zA-Z0-9_ * - simpledata : Set to true if the type of the data you are going to store is scalar, or an array of scalar vars * - staticacceleration : If set to true the cache will hold onto data passing through it. * - staticaccelerationsize : The maximum number of items to hold onto for acceleration purposes. * @return application_cache|session_cache|request_cache */ public function create_cache_from_params($mode, $component, $area, array $identifiers = [], array $options = []) { $identifierstring = empty($identifiers) ? '' : '_' . http_build_query($identifiers); $key = "{$mode}_{$component}_{$area}{$identifierstring}"; if (isset($this->cachesfromparams[$key])) { return $this->cachesfromparams[$key]; } // Regular cache definitions are cached inside create_definition(). This is not the case for Adhoc definitions // using load_adhoc(). They are built as a new object on each call. // We do not need to clone the definition because we know it's new. $definition = definition::load_adhoc($mode, $component, $area, $options); $definition->set_identifiers($identifiers); $cache = $this->create_cache($definition); $this->cachesfromparams[$key] = $cache; return $cache; } /** * Common public method to create a cache instance given a definition. * * This is used by the static make methods. * * @param definition $definition * @return application_cache|session_cache|store * @throws coding_exception */ public function create_cache(definition $definition) { $class = $definition->get_cache_class(); $stores = helper::get_stores_suitable_for_definition($definition); foreach ($stores as $key => $store) { if (!$store::are_requirements_met()) { unset($stores[$key]); } } if (count($stores) === 0) { // Hmm still no stores, better provide a dummy store to mimic functionality. The dev will be none the wiser. $stores[] = $this->create_dummy_store($definition); } $loader = null; if ($definition->has_data_source()) { $loader = $definition->get_data_source(); } while (($store = array_pop($stores)) !== null) { $loader = new $class($definition, $store, $loader); } return $loader; } /** * Creates a store instance given its name and configuration. * * If the store has already been instantiated then the original object will be returned. (reused) * * @param string $name The name of the store (must be unique remember) * @param array $details * @param definition $definition The definition to instantiate it for. * @return boolean|store */ public function create_store_from_config($name, array $details, definition $definition) { if (!array_key_exists($name, $this->stores)) { // Properties: name, plugin, configuration, class. $class = $details['class']; if (!$class::are_requirements_met()) { return false; } $store = new $class($details['name'], $details['configuration']); $this->stores[$name] = $store; } /* @var store $store */ $store = $this->stores[$name]; // We check are_requirements_met although we expect is_ready is going to check as well. if (!$store::are_requirements_met() || !$store->is_ready() || !$store->is_supported_mode($definition->get_mode())) { return false; } // We always create a clone of the original store. // If we were to clone a store that had already been initialised with a definition then // we'd run into a myriad of issues. // We use a method of the store to create a clone rather than just creating it ourselves // so that if any store out there doesn't handle cloning they can override this method in // order to address the issues. $store = $this->stores[$name]->create_clone($details); $store->initialise($definition); $definitionid = $definition->get_id(); if (!isset($this->definitionstores[$definitionid])) { $this->definitionstores[$definitionid] = []; } $this->definitionstores[$definitionid][] = $store; return $store; } /** * Returns an array of cache stores that have been initialised for use in definitions. * @param definition $definition * @return array */ public function get_store_instances_in_use(definition $definition) { $id = $definition->get_id(); if (!isset($this->definitionstores[$id])) { return []; } return $this->definitionstores[$id]; } /** * Returns the cache instances that have been used within this request. * @since Moodle 2.6 * @return array */ public function get_caches_in_use() { return $this->cachesfromdefinitions; } /** * Gets all adhoc caches that have been used within this request. * * @return store[] Caches currently in use */ public function get_adhoc_caches_in_use() { return $this->cachesfromparams; } /** * Creates a cache config instance with the ability to write if required. * * @param bool $writer If set to true an instance that can update the configuration will be returned. * @return config|config_writer */ public function create_config_instance($writer = false) { global $CFG; // The class to use. $class = config::class; // Are we running tests of some form? $testing = (defined('PHPUNIT_TEST') && PHPUNIT_TEST) || defined('BEHAT_SITE_RUNNING'); // Check if this is a PHPUnit test and redirect to the phpunit config classes if it is. if ($testing) { require_once($CFG->dirroot . '/cache/tests/fixtures/lib.php'); // We have just a single class for PHP unit tests. We don't care enough about its // performance to do otherwise and having a single method allows us to inject things into it // while testing. $class = cache_config_testing::class; } // Check if we need to create a config file with defaults. $needtocreate = !$class::config_file_exists(); if ($writer || $needtocreate) { if (!$testing) { $class .= '_writer'; } } $error = false; if ($needtocreate) { // Create the default configuration. // Update the state, we are now initialising the cache. self::set_state(self::STATE_INITIALISING); /** @var config_writer $class */ $configuration = $class::create_default_configuration(); if ($configuration !== true) { // Failed to create the default configuration. Disable the cache stores and update the state. self::set_state(self::STATE_ERROR_INITIALISING); $this->configs[$class] = new $class(); $this->configs[$class]->load($configuration); $error = true; } } if (!array_key_exists($class, $this->configs)) { // Create a new instance and call it to load it. $this->configs[$class] = new $class(); $this->configs[$class]->load(); } if (!$error) { // The cache is now ready to use. Update the state. self::set_state(self::STATE_READY); } // Return the instance. return $this->configs[$class]; } /** * Creates a definition instance or returns the existing one if it has already been created. * @param string $component * @param string $area * @param string $unused This used to be data source aggregate - however that functionality has been removed and * this argument is now unused. * @return definition * @throws coding_exception If the definition cannot be found. */ public function create_definition($component, $area, $unused = null) { $id = $component . '/' . $area; if (!isset($this->definitions[$id])) { // This is the first time this definition has been requested. if ($this->is_initialising()) { // We're initialising the cache right now. Don't try to create another config instance. // We'll just use an ad-hoc cache for the time being. $definition = definition::load_adhoc(store::MODE_REQUEST, $component, $area); } else { // Load all the known definitions and find the desired one. $instance = $this->create_config_instance(); $definition = $instance->get_definition_by_id($id); if (!$definition) { // Oh-oh the definition doesn't exist. // There are several things that could be going on here. // We may be installing/upgrading a site and have hit a definition that hasn't been used before. // Of the developer may be trying to use a newly created definition. if ($this->is_updating()) { // The cache is presently initialising and the requested cache definition has not been found. // This means that the cache initialisation has requested something from a cache (I had recursive nightmares about this). // To serve this purpose and avoid errors we are going to make use of an ad-hoc cache rather than // search for the definition which would possibly cause an infitite loop trying to initialise the cache. $definition = definition::load_adhoc(store::MODE_REQUEST, $component, $area); } else { // Either a typo of the developer has just created the definition and is using it for the first time. $this->reset(); $instance = $this->create_config_instance(true); $instance->update_definitions(); $definition = $instance->get_definition_by_id($id); if (!$definition) { throw new coding_exception('The requested cache definition does not exist.' . $id, $id); } if (!$this->is_disabled()) { debugging('Cache definitions reparsed causing cache reset in order to locate definition. You should bump the version number to ensure definitions are reprocessed.', DEBUG_DEVELOPER); } $definition = definition::load($id, $definition); } } else { $definition = definition::load($id, $definition); } } $this->definitions[$id] = $definition; } return $this->definitions[$id]; } /** * Creates a dummy store object for use when a loader has no potential stores to use. * * @param definition $definition * @return dummy_cachestore */ protected function create_dummy_store(definition $definition) { $store = new dummy_cachestore(); $store->initialise($definition); return $store; } /** * Returns a lock instance ready for use. * * @param array $config * @return lockable_cache_interface */ public function create_lock_instance(array $config) { global $CFG; if (!array_key_exists('name', $config) || !array_key_exists('type', $config)) { throw new coding_exception('Invalid cache lock instance provided'); } $name = $config['name']; $type = $config['type']; unset($config['name']); unset($config['type']); if (!isset($this->lockplugins[$type])) { $pluginname = substr($type, 10); $file = $CFG->dirroot . "/cache/locks/{$pluginname}/lib.php"; if (file_exists($file) && is_readable($file)) { require_once($file); } if (!class_exists($type)) { throw new coding_exception('Invalid lock plugin requested.'); } $this->lockplugins[$type] = $type; } if (!array_key_exists($type, $this->lockplugins)) { throw new coding_exception('Invalid cache lock type.'); } $class = $this->lockplugins[$type]; return new $class($name, $config); } /** * Returns the current state of the cache API. * * @return int */ public function get_state() { return $this->state; } /** * Updates the state fo the cache API. * * @param int $state * @return bool */ public function set_state($state) { if ($state <= $this->state) { return false; } $this->state = $state; return true; } /** * Informs the factory that the cache is currently updating itself. * * This forces the state to upgrading and can only be called once the cache is ready to use. * Calling it ensure we don't try to reinstantite things when requesting cache definitions that don't exist yet. */ public function updating_started() { if ($this->state !== self::STATE_READY) { return false; } $this->state = self::STATE_UPDATING; return true; } /** * Informs the factory that the upgrading has finished. * * This forces the state back to ready. */ public function updating_finished() { $this->state = self::STATE_READY; } /** * Returns true if the cache API has been disabled. * * @return bool */ public function is_disabled() { return $this->state === self::STATE_DISABLED; } /** * Returns true if the cache is currently initialising itself. * * This includes both initialisation and saving the cache config file as part of that initialisation. * * @return bool */ public function is_initialising() { return $this->state === self::STATE_INITIALISING || $this->state === self::STATE_SAVING; } /** * Returns true if the cache is currently updating itself. * * @return bool */ public function is_updating() { return $this->state === self::STATE_UPDATING; } /** * Disables as much of the cache API as possible. * * All of the magic associated with the disabled cache is wrapped into this function. * In switching out the factory for the disabled factory it gains full control over the initialisation of objects * and can use all of the disabled alternatives. * Simple! * * This function has been marked as protected so that it cannot be abused through the public API presently. * Perhaps in the future we will allow this, however as per the build up to the first release containing * MUC it was decided that this was just to risky and abusable. */ protected static function disable() { self::$instance = new disabled_factory(); } /** * Returns true if the cache stores have been disabled. * * @return bool */ public function stores_disabled() { return $this->state === self::STATE_STORES_DISABLED || $this->is_disabled(); } /** * Disables cache stores. * * The cache API will continue to function however none of the actual stores will be used. * Instead the dummy store will be provided for all cache requests. * This is useful in situations where you cannot be sure any stores are working. * * In order to re-enable the cache you must call the cache factories static reset method: * * // Disable the cache factory. * factory::disable_stores(); * // Re-enable the cache factory by resetting it. * factory::reset(); * */ public static function disable_stores() { // First reset to clear any static acceleration array. $factory = self::instance(); $factory->reset_cache_instances(); $factory->set_state(self::STATE_STORES_DISABLED); } /** * Returns an instance of the current display_helper. * * @return administration_helper */ public static function get_administration_display_helper(): administration_helper { if (is_null(self::$displayhelper)) { self::$displayhelper = new \core_cache\local\administration_display_helper(); } return self::$displayhelper; } /** * Gets the config_writer to use when caching is disabled. * This should only be called from disabled_factory. * * @return config_writer */ public static function get_disabled_writer(): config_writer { global $CFG; // Figure out if we are in a recursive loop using late static binding. // This happens when get_disabled_writer is not overridden. We just want the default. $loop = false; if (!empty($CFG->alternative_cache_factory_class)) { $loop = get_called_class() === $CFG->alternative_cache_factory_class; } if (!$loop && !empty($CFG->alternative_cache_factory_class)) { // Get the class to use from the alternative factory. $factoryinstance = new $CFG->alternative_cache_factory_class(); return $factoryinstance::get_disabled_writer(); } else { // We got here from disabled_factory. // We should use the default writer here. // Make sure we have a default config if needed. if (!config::config_file_exists()) { config_writer::create_default_configuration(true); } return new config_writer(); } } } // Alias this class to the old name. // This file will be autoloaded by the legacyclasses autoload system. // In future all uses of this class will be corrected and the legacy references will be removed. class_alias(factory::class, \cache_factory::class); home/smkb8269/public_html/lms.smk-almanshuriyah.sch.id/h5p/classes/factory.php000064400000012515152267236570023215 0ustar00. /** * H5P factory class. * This class is used to decouple the construction of H5P related objects. * * @package core_h5p * @copyright 2019 Mihail Geshoski * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later */ namespace core_h5p; defined('MOODLE_INTERNAL') || die(); use core_h5p\local\library\autoloader; use Moodle\H5PContentValidator as content_validator; use Moodle\H5peditor; use Moodle\H5PStorage as storage; use Moodle\H5PValidator as validator; /** * H5P factory class. * This class is used to decouple the construction of H5P related objects. * * @package core_h5p * @copyright 2019 Mihail Geshoski * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later */ class factory { /** @var \core_h5p\local\library\autoloader The autoloader */ protected $autoloader; /** @var \core_h5p\core The Moodle H5PCore implementation */ protected $core; /** @var \core_h5p\framework The Moodle H5PFramework implementation */ protected $framework; /** @var \core_h5p\file_storage The Moodle H5PStorage implementation */ protected $storage; /** @var validator The Moodle H5PValidator implementation */ protected $validator; /** @var content_validator The Moodle H5PContentValidator implementation */ protected $content_validator; /** @var editor_framework The Moodle H5peditorStorage implementation */ protected $editorframework; /** @var H5peditor */ protected $editor; /** @var editor_ajax The Moodle H5PEditorAjaxInterface implementation */ protected $editorajaxinterface; /** * factory constructor. */ public function __construct() { // Loading classes we need from H5P third party library. $this->autoloader = new autoloader(); autoloader::register(); } /** * Returns an instance of the \core_h5p\local\library\autoloader class. * * @return \core_h5p\local\library\autoloader */ public function get_autoloader(): autoloader { return $this->autoloader; } /** * Returns an instance of the \core_h5p\framework class. * * @return \core_h5p\framework */ public function get_framework(): framework { if (null === $this->framework) { $this->framework = new framework(); } return $this->framework; } /** * Returns an instance of the \core_h5p\core class. * * @return \core_h5p\core */ public function get_core(): core { if (null === $this->core) { $fs = new \core_h5p\file_storage(); $language = \core_h5p\framework::get_language(); $context = \context_system::instance(); $url = \moodle_url::make_pluginfile_url($context->id, 'core_h5p', '', null, '', '')->out(); $this->core = new core($this->get_framework(), $fs, $url, $language, true); } return $this->core; } /** * Returns an instance of the H5PStorage class. * * @return \Moodle\H5PStorage */ public function get_storage(): storage { if (null === $this->storage) { $this->storage = new storage($this->get_framework(), $this->get_core()); } return $this->storage; } /** * Returns an instance of the H5PValidator class. * * @return \Moodle\H5PValidator */ public function get_validator(): validator { if (null === $this->validator) { $this->validator = new validator($this->get_framework(), $this->get_core()); } return $this->validator; } /** * Returns an instance of the H5PContentValidator class. * * @return Moodle\H5PContentValidator */ public function get_content_validator(): content_validator { if (null === $this->content_validator) { $this->content_validator = new content_validator($this->get_framework(), $this->get_core()); } return $this->content_validator; } /** * Returns an instance of H5Peditor class. * * @return H5peditor */ public function get_editor(): H5peditor { if (null === $this->editor) { if (empty($this->editorframework)) { $this->editorframework = new editor_framework(); } if (empty($this->editorajaxinterface)) { $this->editorajaxinterface = new editor_ajax(); } if (empty($this->editor)) { $this->editor = new H5peditor($this->get_core(), $this->editorframework, $this->editorajaxinterface); } } return $this->editor; } }