{@inheritDoc}
@see \Mcustiel\SimpleCache\Interfaces\CacheInterface::set()
178578
public function set(KeyInterface $key, $value, $ttlInMillis)
    {
        return $this->connection->psetex(
            $key,
            $ttlInMillis,
            serialize($value)
        );
    }
1317397
static public function setCache( $value )
	{
		$old = self::$_cache;
		self::$_cache = (boolean) $value;

		return $old;
	}
1345765
public function set($data) {
// 		debug('FSCache set', $data);
// 		debug('FSCache path '.$this->path, $this->editTime.static::$delim.serialize($data));
		try {
			return file_put_contents($this->path, $this->editTime.static::$delim.serialize($data));
		} catch( Exception $e ) {
			throw new CacheException($e->getMessage(), $e->getCode(), $e);
		}
	}
1369427
public function set(string $id, $value): bool
    {
        return $this->getCache()->set($id, $value);
    }
1064117
public function setValue($value): RedisCache
    {
        $redisclient = $this->getRedisConfig()->__invoke();
        $RedisData = (new RedisData())
            ->setData($value);
        $this->value = serialize($RedisData);
        $redisclient->setex($this->getKey(), $this->getExpire(), $this->getValue());

        return $this;
    }
1144337
public function set( $key, $value )
    {
        $cache_file = new File($key.self::CACHE_FILE_EXT, $this->config->getCacheRoot());
    
        $expire = $this->config->getExpire();
        $expires = $expire > 0 ? time() + $this->config->getExpire() : 0;
        $data = base64_encode(serialize($value));
        
        $content[] = 'expires:' . $expires;
        $content[] = 'type:' . gettype($value);
        $content[] = 'class:' . (is_object($value) ? get_class($value) : '');
        $content[] = 'data:' . $data;
    
        $cache_file->putContents(implode("\n",$content));
    }
344258
public function set(string $key, $value)
    {
        $array = &$this->input;
        $keys = explode('.', $key);

        while (count($keys) > 1) {
            $k = array_shift($keys);
            if (!isset($array[$k]) || ! is_array($array[$k])) {
                $array[$k] = [];
            }
            $array = &$array[$k];
        }

        $array[array_shift($keys)] = $value;
        $this->cache[$key] = &$value;
    }
946393
private function setToCache(string $key, $value, $ttl = null): void
    {
        $params = func_get_args();

        // Use default TTL if none is provided
        if ($this->cacheTTL && $ttl === null) {
            array_push($params, $this->cacheTTL);
        }

        call_user_func_array([$this->cache(), 'set'], $params);
    }
120444
public function update($set, $where=array()) {
		$this->provider('cache')->cacheClear('db', $this->getDao()->getTableName());
        $obj = $this->getConnection();
        if (empty($where) == false) {
            foreach ($where as $key => $value) {
                $obj->where($key, $value);                     
            }
        }
        $obj->update($this->getDao()->getTableName(), $set);
        return $obj->count;
	}
1363189
function setCache($cache,$expire=3600)
	{
		$this->cache = $cache;
		$this->if_cache = true;
		$this->expire = $expire;
	}
1130004
public function set($key, $value = null)
    {
        $this->fire('setting', $key, [$key, $value]);

        $generatedKey = $this->getKey($key);

        $serializedValue = $this->serializeValue($value);

        $this->repository->set(
            $generatedKey,
            $this->isEncryptionEnabled()? $this->encrypter->encrypt($serializedValue) : $serializedValue
        );

        if ($this->isCacheEnabled()) {
            $this->cache->forget($generatedKey);
        }

        $this->fire('set', $key, [$key, $value]);

        $this->context(null);
    }
594486
public function set(CacheableInterface $item)
    {
        $con = $this->getConnection();
        $con->set($item->getHashKey(), $item->getDataForCache());
        if (null != $item->getTtl()) {
            $con->expire($item->getHashKey(), $item->getTtl());
        }
    }
784833
public static function set($key, $value, int $ttl = null, array $tags = [])
    {
        $cache = self::getCacheService()->user();
        $item = $cache->getItem(self::key($key));
        $item->set($value);
        if ($ttl) {
            $item->expiresAfter($ttl);
        }
        if ($tags && $item instanceof CacheItem) {
            $item->tag($tags);
        }
        self::getCacheService()->user()->save($item);
    }
316814
protected function _set()
	{
		// get the apc key for the cache identifier
		$key = $this->_get_key();

		$payload = $this->prep_contents();

		// adjust the expiration, apc uses a TTL instead of a timestamp
		$expiration = is_null($this->expiration) ? 0 : (int) ($this->expiration - $this->created);

		// write it to the apc store
		if (apc_store($key, $payload, $expiration) === false)
		{
			throw new \RuntimeException('APC returned failed to write. Check your configuration.');
		}

		// update the index
		$this->_update_index($key);

		return true;
	}
554706
static public function setCache( $value )
	{
		$old = self::$cache;
		self::$cache = (boolean) $value;

		return $old;
	}
159720
function set($key, $value)
    {
        $index = array_search($key, $this->keys);

        if ($index !== false) {
            $this->values[$index] = $value;
        } else {
            $this->keys[] = $key;
            $this->values[] = $value;
        }
    }
15788
public function set($key, $values, $replace = true)
    {
        $key = strtr(strtolower($key), '_', '-');

        $values = array_values((array) $values);

        if (true === $replace || !isset($this->headers[$key])) {
            $this->headers[$key] = $values;
        } else {
            $this->headers[$key] = array_merge($this->headers[$key], $values);
        }

        if ('cache-control' === $key) {
            $this->cacheControl = $this->parseCacheControl($values[0]);
        }
    }