Returns the supported adapter for the repository.

@return AdapterInterface|null
324757
public function getAdapter()
    {
        if ($this->repositoryAdapter instanceof AdapterInterface) {
            return $this->repositoryAdapter;
        }

        foreach ($this->adapters as $adapterClass) {
            if (class_exists($adapterClass) === false || in_array('Accompli\Chrono\Adapter\AdapterInterface', class_implements($adapterClass)) === false) {
                continue;
            }

            $adapter = new $adapterClass($this->repositoryUrl, $this->repositoryDirectory, $this->processExecutor);
            if ($adapter->supportsRepository()) {
                return $adapter;
            }
        }
    }
1116120
public function getAdapter()
    {
        $this->count++;
        if (is_null($this->adapter)) {
            $fss = $this->getServiceManager()->get(FileSystemService::SERVICE_ID);
            $this->adapter = $fss->getFileSystem($this->getOption('inner'))->getAdapter();
        }
        return $this->adapter;
    }
34326
protected function getAdapter() : AdapterInterface
    {
        if ($this->adapter === null) {
            $databaseFile = $this->getTemporaryFileName();
            $adapter = AdapterFactory::getInstance($databaseFile);
            $this->setAdapter($adapter);
        }

        return $this->adapter;
    }
860556
public function getAdapter()
    {
        if ($this->adapter instanceof Compress\CompressionAlgorithmInterface) {
            return $this->adapter;
        }

        $adapter = $this->adapter;
        $options = $this->getAdapterOptions();
        if (!class_exists($adapter)) {
            $adapter = 'Zend\\Filter\\Compress\\' . ucfirst($adapter);
            if (!class_exists($adapter)) {
                throw new Exception\RuntimeException(sprintf(
                    '%s unable to load adapter; class "%s" not found',
                    __METHOD__,
                    $this->adapter
                ));
            }
        }

        $this->adapter = new $adapter($options);
        if (!$this->adapter instanceof Compress\CompressionAlgorithmInterface) {
            throw new Exception\InvalidArgumentException("Compression adapter '" . $adapter . "' does not implement Zend\\Filter\\Compress\\CompressionAlgorithmInterface");
        }
        return $this->adapter;
    }
779239
public function getLayoutAdapter()
    {
        if (null === $this->layoutAdapter) {
            $class = $this->config['layout']['adapter'];

            $this->layoutAdapter = new $class;
            $this->layoutAdapter->setEditor($this);
        }

        return $this->layoutAdapter;
    }
1088685
public function getAdapter() {
		if ($this->_adapter === null) {
			$this->_adapter = $this->getLocator()->get(self::DEFAULT_LOGGER_ADAPTER);

			if (! $this->_adapter instanceof AdapterInterface) {
				throw new NoAdapter('Adapter must implement the "AdapterInterface"');
			}
		}
		
		return $this->_adapter;
	}
511203
public function getAdapter()
    {
        if (empty($this->adapter)) {
            $user = $this->getUser();
            $sessionDataStored = $user->getAuthSession($this->providerKey);
            $hybridAuth = $this->getHybridAuth();
            if (!empty($sessionDataStored)) {
                $hybridAuth->restoreSessionData($sessionDataStored);
            }
            $adapter = $hybridAuth->authenticate($this->providerKey);
            $sessionData    = $hybridAuth->getSessionData();
            if ($sessionData != $sessionDataStored) {
                $user->updateAuthSession($this->providerKey, $sessionData);
            }
            $this->adapter = $adapter;
        }
        return $this->adapter;
    }
645344
public function getReadConnection(AdapterInterface $adapter = null)
    {
        if ($this->writeConnection && $this->writeConnection->inTransaction()) {
            return $this->writeConnection;
        }

        if ($this->isForceMasterConnection()) {
            return $this->getWriteConnection($adapter);
        }
        if (null === $this->readConnection) {
            if (null === $this->readConfiguration) {
                $this->readConnection = $this->getWriteConnection($adapter);
            } else {
                $keys = array_keys($this->readConfiguration);
                $key = $keys[mt_rand(0, count($keys) - 1)];
                $configuration = $this->readConfiguration[$key];
                $this->readConnection = ConnectionFactory::create($configuration, $adapter);
                $this->readConnection->setName($this->getName());
            }
        }

        return $this->readConnection;
    }
533724
private function getAdapter(TableInterface $table, $format)
    {
        $adapters = $table->getConfig()->getExportAdapters();

        foreach ($adapters as $adapter) {
            if ($adapter->supports($format)) {
                return $adapter;
            }
        }

        return null;
    }
671513
protected static function getFacadeAccessor()
    {
    	$viewPath = dirname(dirname(dirname(__DIR__)));
        $adapter = new Local($viewPath);
        $filesystem = new Filesystem($adapter);
        return $filesystem;
    }
928290
protected static function getAdapter(?string $adapter = null): AbstractMailAdapter
    {
        $config = static::getConfig();

        if (static::$firstKey === null) {
            static::$firstKey = $config->getFirstKey();
        }

        $key = $adapter ?? static::$firstKey;
        $configArray = $config->get($key, []);

        if (($configArray['enabled'] ?? false) === true) {
            if (isset($configArray['module'])) {
                Application::registerModule($configArray['module']);
            }

            $className = $configArray['adapter_class'] ?? null;

            if ($className === null) {
                throw new ConfigException("Key 'adapter_class' is not set in mail config={$key}");
            }

            if (!class_exists($className, true)) {
                throw new ConfigException("Unknown mail class={$className} under key={$adapter}");
            }

            return new $className($configArray['options'] ?? []);
        }

        return new Simulate($configArray['options'] ?? []);
    }
804425
public function getRepository()
    {
        if (!$this->_repository instanceof AnDomainRepositoryAbstract) {
            if (!$this->_repository instanceof AnServiceIdentifier) {
                $this->setRepository($this->_repository);
            }

            $this->_repository = $this->getService($this->_repository);
        }

        return $this->_repository;
    }
823329
public function getAdapter($mimeTypes)
    {
        $mimeTypes = explode(';', $mimeTypes);

        foreach ($mimeTypes as $mimeType) {
            foreach ($this->adapters as $adapter) {
                if (in_array(ltrim($mimeType), $adapter->getMimeTypes())) {
                    return $adapter;
                }
            }
        }

        throw new \Exception('No adapter found for mime type '.$mimeType);
    }
755333
public function getESAdaptor()
    {
        if (empty($this->adaptor)) {

            $this->assertion->isInstanceOf(
                $this->decorator,
                '\Liip\Registry\Adaptor\Decorator\DecoratorInterface',
                'Mandatory decorator object is not defined.'
            );

            $this->adaptor = new ElasticaAdaptor($this->decorator);
        }

        return $this->adaptor;
    }
248912
public function getSourceAdapter($name)
    {
        foreach (array_reverse($this->sourceAdapters) as $pattern => $adapter) {
            if (preg_match($pattern, $name)) {
                return $adapter;
            }
        }

        return null;
    }
1084986
public function getHttpAdapter()
    {
        if (null === $this->httpAdapter) {
            $this->httpAdapter = new Http\Client\Adapter\Curl();
            $this->httpAdapter->setOptions(array(
                'curloptions' => array(
                    CURLOPT_SSL_VERIFYPEER => false,
                ),
            ));
        }

        return $this->httpAdapter;
    }
112861
public function getSystem(): Adapter\System
    {
        if ($this->system === null) {
            $this->system = new Adapter\System($this);
        }

        return $this->system;
    }