$head = (array)$file->content();
            static::$instances[$outline] = new static(isset($head['atoms']) ? $head['atoms'] : [], $outline);
            $file->free();
 
            static::$instances[$outline]->init();
        }
 
        return static::$instances[$outline];
    }
 
    /**
     * Atoms constructor.
     * @param array $atoms
     * @param string $name
     */
    public function __construct(array $atoms = [], $name = null)
    {
        $this->name = $name;
        $this->items = array_filter($atoms);
        $this->inherit = file_exists('gantry-admin://blueprints/layout/inheritance/atom.yaml');
 
        foreach ($this->items as &$item) {
            if (!empty($item['id'])) {
                $this->ids[$item['id']] = $item;
            }
        }
    }
 
    /**
     * @return $this
     */
    public function init()
    {
        foreach ($this->items as &$item) {
            if (!empty($item['inherit']['outline']) && !empty($item['inherit']['atom'])) {
                $inherited = static::instance($item['inherit']['outline']);
                $test = $inherited->id($item['inherit']['atom']);
                if (isset($test['attributes'])) {
                    $item['attributes'] = $test['attributes'];
                } else {

 
        // Locate all configuration files to be compiled.
        $files = (new ConfigFileFinder)->locateFiles($paths);
 
        $cache = $locator->findResource('gantry-cache://theme/compiled/config', true, true);
        if (is_bool($cache)) {
            throw new \RuntimeException('Who just removed Gantry 5 cache folder? Try reloading the page if it fixes the issue');
        }
 
        $compiled = new CompiledConfig($cache, $files, GANTRY5_ROOT);
        $compiled->setBlueprints(static function() use ($container) {
            return $container['blueprints'];
        });
 
        $config = $compiled->load($withDefaults);
 
        // Set atom inheritance.
        $atoms = $config->get('page.head.atoms');
        if (is_array($atoms)) {
            $config->set('page.head.atoms', (new Atoms($atoms))->init()->toArray());
        }
 
        // Set FA default in Joomla
        if (class_exists(Version::class)) {
            $config->def('page.fontawesome.default_version', Version::MAJOR_VERSION < 4 ? 'fa4' : 'fa5css');
        } else {
            $config->def('page.fontawesome.default_version', 'fa4');
        }
 
        return $config;
    }
}
 

        if ($force) {
            unset($gantry['configuration']);
        }
 
        // Set default name only if configuration has not been set before.
        if ($name === null && !isset($gantry['configuration'])) {
            $name = 'default';
        }
 
        $outline = isset($gantry['configuration']) ? $gantry['configuration'] : null;
 
        // Set configuration if given.
        if ($name && $name !== $outline) {
            if (\GANTRY_DEBUGGER) {
                Debugger::addMessage("Using Gantry outline {$name}");
            }
 
            $gantry['configuration'] = $name;
            unset($gantry['config']);
            $gantry['config'] = ConfigServiceProvider::load($gantry, $name);
        }
 
        return $this;
    }
 
    /**
     * Get current preset.
     *
     * @param  bool $forced     If true, return only forced preset or null.
     * @return string|null $preset
     */
    public function preset($forced = false)
    {
        $presets = $this->presets()->toArray();
 
        $preset = $this->preset;
 
        if (!$preset && !$forced) {
            /** @var Config $config */
            $config = static::gantry()['config'];

        }
 
        if (\GANTRY_DEBUGGER) {
            Debugger::addMessage("Using Gantry 5 template {$templateName}");
        }
 
        /** @var Theme $theme */
        $theme = $gantry['theme'];
 
        $assignments = new Assignments();
 
        if (\GANTRY_DEBUGGER) {
            Debugger::addMessage('Selecting outline (rules, matches, scores):', 'debug');
            Debugger::addMessage($assignments->getPage(), 'debug');
            Debugger::addMessage($assignments->loadAssignments(), 'debug');
            Debugger::addMessage($assignments->matches(), 'debug');
            Debugger::addMessage($assignments->scores(), 'debug');
        }
 
        $theme->setLayout($assignments->select());
 
        if ($this->params->get('asset_timestamps', 1)) {
            $age = (int)($this->params->get('asset_timestamps_period', 7) * 86400);
            Document::$timestamp_age = $age > 0 ? $age : PHP_INT_MAX;
        } else {
            Document::$timestamp_age = 0;
        }
    }
 
    /**
     * Re-route Gantry templates to Gantry Administration component.
     */
    private function onAfterRouteAdmin()
    {
        $input = $this->app->input;
 
        $option = $input->getCmd('option');
        $task   = $input->getCmd('task');
 
        if (in_array($option, array('com_templates', 'com_advancedtemplates'), true)) {

 
    /**
     * Return global configuration for Gantry5.
     *
     * @param array $global
     */
    public function onGantryGlobalConfig(&$global)
    {
        $global = $this->params->toArray();
    }
 
    public function onAfterRoute()
    {
        if (version_compare(JVERSION, '4.0', '<')) {
            // In Joomla 3.9 we need to make sure that user identity has been loaded.
            $this->app->loadIdentity();
        }
 
        if ($this->app->isClient('site')) {
            $this->onAfterRouteSite();
 
        } elseif ($this->app->isClient('administrator')) {
            $this->onAfterRouteAdmin();
        }
    }
 
    /**
     * Document gets set during dispatch, we need language and direction.
     */
    public function onAfterDispatch()
    {
        if (class_exists('Gantry\Framework\Gantry')) {
            $this->onAfterDispatchSiteAdmin();
        }
    }
 
    public function onAfterRender()
    {
        if ($this->app->isClient('site') && class_exists('Gantry\Framework\Gantry')) {
            $this->onAfterRenderSite();

     * @param   array  &$args  Arguments
     *
     * @return  mixed  Routine return value
     *
     * @since   1.5
     */
    public function update(&$args)
    {
        // First let's get the event from the argument array.  Next we will unset the
        // event argument as it has no bearing on the method to handle the event.
        $event = $args['event'];
        unset($args['event']);
 
        /*
         * If the method to handle an event exists, call it and return its return
         * value.  If it does not exist, return null.
         */
        if (method_exists($this, $event))
        {
            return call_user_func_array(array($this, $event), array_values($args));
        }
    }
}
 

        if (!isset($this->_methods[$event]) || empty($this->_methods[$event]))
        {
            // No Plugins Associated To Event!
            return $result;
        }
 
        // Loop through all plugins having a method matching our event
        foreach ($this->_methods[$event] as $key)
        {
            // Check if the plugin is present.
            if (!isset($this->_observers[$key]))
            {
                continue;
            }
 
            // Fire the event for an object based observer.
            if (is_object($this->_observers[$key]))
            {
                $args['event'] = $event;
                $value = $this->_observers[$key]->update($args);
            }
            // Fire the event for a function based observer.
            elseif (is_array($this->_observers[$key]))
            {
                $value = call_user_func_array($this->_observers[$key]['handler'], array_values($args));
            }
 
            if (isset($value))
            {
                $result[] = $value;
            }
        }
 
        return $result;
    }
 
    /**
     * Attach an observer object
     *
     * @param   object  $observer  An observer object to attach

        }
 
        return $this;
    }
 
    /**
     * Calls all handlers associated with an event group.
     *
     * @param   string  $event  The event name.
     * @param   array   $args   An array of arguments (optional).
     *
     * @return  array   An array of results from each function call, or null if no dispatcher is defined.
     *
     * @since   3.0.0
     */
    public function triggerEvent($event, array $args = null)
    {
        if ($this->dispatcher instanceof \JEventDispatcher)
        {
            return $this->dispatcher->trigger($event, $args);
        }
 
        return;
    }
 
    /**
     * Allows the application to load a custom or default dispatcher.
     *
     * The logic and options for creating this object are adequately generic for default cases
     * but for many applications it will make sense to override this method and create event
     * dispatchers, if required, based on more specific needs.
     *
     * @param   \JEventDispatcher  $dispatcher  An optional dispatcher object. If omitted, the factory dispatcher is created.
     *
     * @return  BaseApplication This method is chainable.
     *
     * @since   3.0.0
     */
    public function loadDispatcher(\JEventDispatcher $dispatcher = null)
    {

 
                    $this->setHeader('Expires', 'Wed, 17 Aug 2005 00:00:00 GMT', true);
                    $this->setHeader('Last-Modified', gmdate('D, d M Y H:i:s') . ' GMT', true);
                    $this->setHeader('Cache-Control', 'no-store, no-cache, must-revalidate, post-check=0, pre-check=0', false);
                    $this->setHeader('Pragma', 'no-cache');
                    $this->sendHeaders();
 
                    $this->redirect((string) $oldUri, 301);
                }
            }
        }
 
        foreach ($result as $key => $value)
        {
            $this->input->def($key, $value);
        }
 
        // Trigger the onAfterRoute event.
        \JPluginHelper::importPlugin('system');
        $this->triggerEvent('onAfterRoute');
    }
 
    /**
     * Sets the value of a user state variable.
     *
     * @param   string  $key    The path of the state.
     * @param   mixed   $value  The value of the variable.
     *
     * @return  mixed  The previous state, if one existed.
     *
     * @since   3.2
     */
    public function setUserState($key, $value)
    {
        $session = \JFactory::getSession();
        $registry = $session->get('registry');
 
        if ($registry !== null)
        {
            return $registry->set($key, $value);

 
        parent::render();
    }
 
    /**
     * Route the application.
     *
     * Routing is the process of examining the request environment to determine which
     * component should receive the request. The component optional parameters
     * are then set in the request object to be processed when the application is being
     * dispatched.
     *
     * @return  void
     *
     * @since   3.2
     */
    protected function route()
    {
        // Execute the parent method
        parent::route();
 
        $Itemid = $this->input->getInt('Itemid', null);
        $this->authorise($Itemid);
    }
 
    /**
     * Set the current state of the detect browser option.
     *
     * @param   boolean  $state  The new state of the detect browser option
     *
     * @return    boolean     The previous state
     *
     * @since    3.2
     */
    public function setDetectBrowser($state = false)
    {
        $old = $this->_detect_browser;
        $this->_detect_browser = $state;
 
        return $old;

        $this->triggerEvent('onAfterDispatch');
    }
 
    /**
     * Method to run the Web application routines.
     *
     * @return  void
     *
     * @since   3.2
     */
    protected function doExecute()
    {
        // Initialise the application
        $this->initialiseApp();
 
        // Mark afterInitialise in the profiler.
        JDEBUG ? $this->profiler->mark('afterInitialise') : null;
 
        // Route the application
        $this->route();
 
        // Mark afterRoute in the profiler.
        JDEBUG ? $this->profiler->mark('afterRoute') : null;
 
        /*
         * Check if the user is required to reset their password
         *
         * Before $this->route(); "option" and "view" can't be safely read using:
         * $this->input->getCmd('option'); or $this->input->getCmd('view');
         * ex: due of the sef urls
         */
        $this->checkUserRequireReset('com_users', 'profile', 'edit', 'com_users/profile.save,com_users/profile.apply,com_users/user.logout');
 
        // Dispatch the application
        $this->dispatch();
 
        // Mark afterDispatch in the profiler.
        JDEBUG ? $this->profiler->mark('afterDispatch') : null;
    }
 

            array('option', 'view', 'format', 'lang', 'Itemid', 'template', 'templateStyle', 'task'),
            function($systemVariable) use ($input) {
                return $input->exists($systemVariable) && is_array($input->getRaw($systemVariable));
            }
        );
 
        // Unset invalid system variables
        foreach ($invalidInputVariables as $systemVariable)
        {
            $input->set($systemVariable, null);
        }
 
        // Abort when there are invalid variables
        if ($invalidInputVariables)
        {
            throw new \RuntimeException('Invalid input, aborting application.');
        }
 
        // Perform application routines.
        $this->doExecute();
 
        // If we have an application document object, render it.
        if ($this->document instanceof \JDocument)
        {
            // Render the application output.
            $this->render();
        }
 
        // If gzip compression is enabled in configuration and the server is compliant, compress the output.
        if ($this->get('gzip') && !ini_get('zlib.output_compression') && ini_get('output_handler') !== 'ob_gzhandler')
        {
            $this->compress();
 
            // Trigger the onAfterCompress event.
            $this->triggerEvent('onAfterCompress');
        }
 
        // Send the application response.
        $this->respond();
 

{
    include_once __DIR__ . '/defines.php';
}
 
if (!defined('_JDEFINES'))
{
    define('JPATH_BASE', __DIR__);
    require_once JPATH_BASE . '/includes/defines.php';
}
 
require_once JPATH_BASE . '/includes/framework.php';
 
// Set profiler start time and memory usage and mark afterLoad in the profiler.
JDEBUG ? JProfiler::getInstance('Application')->setStart($startTime, $startMem)->mark('afterLoad') : null;
 
// Instantiate the application.
$app = JFactory::getApplication('site');
 
// Execute the application.
$app->execute();