lib.smpn2kalipuro.sch.id

Windows NT WIN-RSHGLQSEGL8 10.0 build 17763 (Windows Server 2016) AMD64
Apache/2.4.41 (Win64) PHP/7.3.12
192.168.1.200
Cant read /etc/named.conf

File Name : StorageFactory.php

<?php
/**
 * Zend Framework (http://framework.zend.com/)
 *
 * @link      http://github.com/zendframework/zf2 for the canonical source repository
 * @copyright Copyright (c) 2005-2016 Zend Technologies USA Inc. (http://www.zend.com)
 * @license   http://framework.zend.com/license/new-bsd New BSD License
 */

namespace Zend\Cache;

use Traversable;
use Zend\EventManager\EventsCapableInterface;
use Zend\Stdlib\ArrayUtils;
use Zend\ServiceManager\ServiceManager;

abstract class StorageFactory
{
    /**
     * Plugin manager for loading adapters
     *
     * @var null|Storage\AdapterPluginManager
     */
    protected static $adapters = null;

/**
     * Plugin manager for loading plugins
     *
     * @var null|Storage\PluginManager
     */
    protected static $plugins = null;

/**
     * The storage factory
     * This can instantiate storage adapters and plugins.
     *
     * @param array|Traversable $cfg
     * @return Storage\StorageInterface
     * @throws Exception\InvalidArgumentException
     */
    public static function factory($cfg)
    {
        if ($cfg instanceof Traversable) {
            $cfg = ArrayUtils::iteratorToArray($cfg);
        }

if (!is_array($cfg)) {
            throw new Exception\InvalidArgumentException(
                'The factory needs an associative array '
                . 'or a Traversable object as an argument'
            );
        }

// instantiate the adapter
        if (!isset($cfg['adapter'])) {
            throw new Exception\InvalidArgumentException('Missing "adapter"');
        }
        $adapterName    = $cfg['adapter'];
        $adapterOptions = [];
        if (is_array($cfg['adapter'])) {
            if (!isset($cfg['adapter']['name'])) {
                throw new Exception\InvalidArgumentException('Missing "adapter.name"');
            }

$adapterName    = $cfg['adapter']['name'];
            $adapterOptions = isset($cfg['adapter']['options']) ? $cfg['adapter']['options'] : [];
        }
        if (isset($cfg['options'])) {
            $adapterOptions = array_merge($adapterOptions, $cfg['options']);
        }

$adapter = static::adapterFactory((string) $adapterName, $adapterOptions);

// add plugins
        if (isset($cfg['plugins'])) {
            if (!$adapter instanceof EventsCapableInterface) {
                throw new Exception\RuntimeException(sprintf(
                    "The adapter '%s' doesn't implement '%s' and therefore can't handle plugins",
                    get_class($adapter),
                    'Zend\EventManager\EventsCapableInterface'
                ));
            }

if (!is_array($cfg['plugins'])) {
                throw new Exception\InvalidArgumentException(
                    'Plugins needs to be an array'
                );
            }

foreach ($cfg['plugins'] as $k => $v) {
                $pluginPrio = 1; // default priority

if (is_string($k)) {
                    if (!is_array($v)) {
                        throw new Exception\InvalidArgumentException(
                            "'plugins.{$k}' needs to be an array"
                        );
                    }
                    $pluginName    = $k;
                    $pluginOptions = $v;
                } elseif (is_array($v)) {
                    if (!isset($v['name'])) {
                        throw new Exception\InvalidArgumentException("Invalid plugins[{$k}] or missing plugins[{$k}].name");
                    }
                    $pluginName = (string) $v['name'];

if (isset($v['options'])) {
                        $pluginOptions = $v['options'];
                    } else {
                        $pluginOptions = [];
                    }

if (isset($v['priority'])) {
                        $pluginPrio = $v['priority'];
                    }
                } else {
                    $pluginName    = $v;
                    $pluginOptions = [];
                }

$plugin = static::pluginFactory($pluginName, $pluginOptions);
                if (! $adapter->hasPlugin($plugin)) {
                    $adapter->addPlugin($plugin, $pluginPrio);
                }
            }
        }

return $adapter;
    }

/**
     * Instantiate a storage adapter
     *
     * @param  string|Storage\StorageInterface                  $adapterName
     * @param  array|Traversable|Storage\Adapter\AdapterOptions $options
     * @return Storage\StorageInterface
     * @throws Exception\RuntimeException
     */
    public static function adapterFactory($adapterName, $options = [])
    {
        if ($adapterName instanceof Storage\StorageInterface) {
            // $adapterName is already an adapter object
            $adapter = $adapterName;
        } else {
            $adapter = static::getAdapterPluginManager()->get($adapterName);
        }

if ($options) {
            $adapter->setOptions($options);
        }

return $adapter;
    }

/**
     * Get the adapter plugin manager
     *
     * @return Storage\AdapterPluginManager
     */
    public static function getAdapterPluginManager()
    {
        if (static::$adapters === null) {
            static::$adapters = new Storage\AdapterPluginManager(new ServiceManager);
        }
        return static::$adapters;
    }

/**
     * Change the adapter plugin manager
     *
     * @param  Storage\AdapterPluginManager $adapters
     * @return void
     */
    public static function setAdapterPluginManager(Storage\AdapterPluginManager $adapters)
    {
        static::$adapters = $adapters;
    }

/**
     * Resets the internal adapter plugin manager
     *
     * @return void
     */
    public static function resetAdapterPluginManager()
    {
        static::$adapters = null;
    }

/**
     * Instantiate a storage plugin
     *
     * @param string|Storage\Plugin\PluginInterface     $pluginName
     * @param array|Traversable|Storage\Plugin\PluginOptions $options
     * @return Storage\Plugin\PluginInterface
     * @throws Exception\RuntimeException
     */
    public static function pluginFactory($pluginName, $options = [])
    {
        if ($pluginName instanceof Storage\Plugin\PluginInterface) {
            // $pluginName is already a plugin object
            $plugin = $pluginName;
        } else {
            $plugin = static::getPluginManager()->get($pluginName);
        }

if ($options) {
            if (!$options instanceof Storage\Plugin\PluginOptions) {
                $options = new Storage\Plugin\PluginOptions($options);
            }
            $plugin->setOptions($options);
        }

return $plugin;
    }

/**
     * Get the plugin manager
     *
     * @return Storage\PluginManager
     */
    public static function getPluginManager()
    {
        if (static::$plugins === null) {
            static::$plugins = new Storage\PluginManager(new ServiceManager);
        }
        return static::$plugins;
    }

/**
     * Change the plugin manager
     *
     * @param  Storage\PluginManager $plugins
     * @return void
     */
    public static function setPluginManager(Storage\PluginManager $plugins)
    {
        static::$plugins = $plugins;
    }

/**
     * Resets the internal plugin manager
     *
     * @return void
     */
    public static function resetPluginManager()
    {
        static::$plugins = null;
    }
}

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	0/0	drwxrwxrwx	2020-11-18 04:21:40
..	dir	-	0/0	drwxrwxrwx	2020-11-18 04:21:40
Exception	dir	-	0/0	drwxrwxrwx	2020-11-18 04:21:40
Pattern	dir	-	0/0	drwxrwxrwx	2020-11-18 04:21:40
Service	dir	-	0/0	drwxrwxrwx	2020-11-18 04:21:40
Storage	dir	-	0/0	drwxrwxrwx	2020-11-18 04:21:40
ConfigProvider.php	text/x-php	1.19 KB	0/0	-rw-rw-rw-	2016-04-25 03:08:21
Module.php	text/x-php	625 B	0/0	-rw-rw-rw-	2016-04-25 03:08:21
PatternFactory.php	text/x-php	2.58 KB	0/0	-rw-rw-rw-	2016-04-25 03:08:21
PatternPluginManager.php	text/x-php	4.37 KB	0/0	-rw-rw-rw-	2016-04-25 03:08:21
StorageFactory.php	text/x-php	7.54 KB	0/0	-rw-rw-rw-	2016-04-25 03:08:21