Set Adapter interface

@param \Desarrolla2\Cache\Adapter\AdapterInterface $adapter
498609
public function setAdapter(\Desarrolla2\Cache\Adapter\AdapterInterface $adapter)
    {
        return $this->_instance->setAdapter($adapter);
    }
931108
public function getWriteConnection(AdapterInterface $adapter = null)
    {
        if (null === $this->writeConnection) {
            $this->writeConnection = ConnectionFactory::create($this->writeConfiguration, $adapter);
            $this->writeConnection->setName($this->getName());
        }

        return $this->writeConnection;
    }
836339
public static function getAdapter($adapter)
    {
        $config = Config::get('cache');

        if ($config && $adapter && isset($config['enabled']) && $config['enabled']) {
            if (!isset($config['pools'][$adapter])) {
                throw new ComponentException("Class `Proxy\\Cache` required configuration for `$adapter` adapter");
            }
            if (!isset(static::$pools[$adapter])) {
                static::$pools[$adapter] = $config['pools'][$adapter]();
            }
            return static::$pools[$adapter];
        }
        return false;
    }
850639
public function addAdaptor(AbstractAdaptor $adaptor)
    {
        // The key will be the adaptor's name or the next numerical
        // count if a name is blank
        $adaptorName = $adaptor->getName() ?: $this->adaptorCount;
        $this->adaptors[$adaptorName] = $adaptor;
        $this->adaptorCount++;
    }
382884
public function createIdentity(AdapterInterface $adapter): IdentityInterface
    {
        $map = new $this->attribute_map_class($adapter->getAttributeMap(), $this->logger);
        $this->identity = new $this->identity_class($adapter, $map, $this->logger);

        return $this->identity;
    }
830338
public function setEventDispatcher(EventDispatcherInterface $eventDispatcher)
	{
		$this->eventDispatcher = $eventDispatcher;
		$this->twig->setEventDispatcher($eventDispatcher);
	}
824745
protected function createFilesystem(AdapterInterface $adapter, array $config)
    {
        $cache = Arr::pull($config, 'cache');

        $config = Arr::only($config, ['visibility', 'disable_asserts', 'url']);

        if ($cache) {
            $adapter = new CachedAdapter($adapter, $this->createCacheStore($cache));
        }

        return new Filesystem($adapter, count($config) > 0 ? $config : null);
    }
103910
public function setAdapter($adapter)
    {
        if ($adapter == null) {
            $this->adapter = $adapter;
        } else {
              parent::setAdapter($adapter);
        }
    }
77694
public function setAdapter(AdapterInterface $v)
    {
        $this->db = $v;
        foreach ($this->clauses as $clause) {
            $clause->setAdapter($v);
        }
    }
105949
public function get(array $adapters, CacheableInterface $item)
    {
        foreach ($adapters as $adapter) {

            if (false !== $value = $adapter->get($item)) {
                return $value;
            }
        }

        return false;
    }
787938
public function setAdapter($adapter)
    {
        switch (strtolower($adapter)) {
            case 'sodium':
                $adapterSet = '\Zest\Encryption\Adapter\SodiumEncryption';
                break;
            case 'openssl':
                $adapterSet = '\Zest\Encryption\Adapter\OpenSslEncryption';
                break;
            default:
                $adapterSet = '\Zest\Encryption\Adapter\OpenSslEncryption';
                break;
        }
        $key = __config()->encryption->key;
        $this->adapter = new $adapterSet($key);

        return $this;
    }
1099950
public function mountFilesystem($prefix, AdapterInterface $adapter)
    {
        return $this->manager->mountFilesystem($prefix, new Fs($adapter));
    }
264596
public static function getAdapter(string $adapter = null): AbstractCacheAdapter
    {
        $key = $adapter ?? static::getConfig()->getFirstKey();

        if (isset(static::$adapters[$key])) {
            return static::$adapters[$key];
        }

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

        if (($configArray['enabled'] ?? false) === false) {
            static::$adapters[$key] = new Cache\Adapter\DevNull([]);
        } else {

            if (isset($configArray['module'])) {
                Application::registerModule($configArray['module']);
            }

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

            if ($className === null) {
                throw new ConfigException("Cache config under key={$key} doesn\'t have defined 'adapter_class'; please set the 'adapter_class' with the name of class that extends \\Koldy\\Cache\\Adapter\\AbstractCacheAdapter");
            }

            if (!class_exists($className, true)) {
                throw new ConfigException("Class={$className} defined in cache config under key={$adapter} wasn't found; check the name and namespace of class and if class can be loaded");
            }

            static::$adapters[$key] = new $className($configArray['options'] ?? []);
        }

        return static::$adapters[$key];
    }
1091293
public function setAdapter( tao_helpers_grid_Cell_Adapter $adapter)
    {
        $returnValue = (bool) false;

        
		if(!is_null($adapter)){
			$this->adapters[] = $adapter;
			$returnValue = true;
		}
        

        return (bool) $returnValue;
    }
307292
public function setAdapters($adapters)
    {
        $this->adapterClasses = [];
        $this->adapters = [];
        foreach ($adapters as $name => $adapter) {
            $this->setAdapter($name, $adapter);
        }
    }
597449
public function setCollector(ResourceCollectorInterface $collector)
    {
        $this->collector = $collector;

        if ($this->loader) {
            if ($this->loader instanceof ResourceAwareInterface) {
                $this->loader->setResourceCollector($collector);
            }

            if ($this->loader instanceof DelegatingLoader) {
                $resolver = $this->loader->getResolver();

                if ($resolver instanceof ResourceAwareInterface) {
                    $resolver->setResourceCollector($collector);
                }
            }
        }
    }
1252816
public function setAdapterClass($name, $adapterClass)
    {
        $this->adapterClasses[$name] = $adapterClass;
        unset($this->adapters[$name]);
    }