Set the cache_dir (particular case of setOption() method)

@param  string  $value
@param  boolean $trailingSeparator If true, add a trailing separator is necessary
@throws Zend_Cache_Exception
@return void
421099
public function setCacheDir($value, $trailingSeparator = true)
    {
        if (!is_dir($value)) {
            Zend_Cache::throwException('cache_dir must be a directory');
        }
        if (!is_writable($value)) {
            Zend_Cache::throwException('cache_dir is not writable');
        }
        if ($trailingSeparator) {
            // add a trailing DIRECTORY_SEPARATOR if necessary
            $value = rtrim(realpath($value), '\\/') . DIRECTORY_SEPARATOR;
        }
        $this->_options['cache_dir'] = $value;
    }
680959
public function setDirectOnly($value)
    {
        if ($value !== null) {
            if($value == true) {
                $this->_params['directOnly'] = 'true';
            } else {
                $this->_params['directOnly'] = 'false';
            }
        } else {
            unset($this->_params['directOnly']);
        }
    }
790585
public function setPage($value)
    {
        if ($value === null || $value === '') {
            $this->_page = null;
        } elseif (TypeCast::canCastToString($value)) {
            $this->_page = (string)$value;
        } else {
            throw new InvalidPropertyValueTypeException(
                'Invalid status value in PaymentsRequest', 0, 'PaymentsRequest.page', $value
            );
        }
    }
328570
public function set($key, $value, $seconds, $strict = true) {
        $set = $this->memcached->set($key, $value, $seconds);
        if (!$set && $strict) {
            throw new CacheSetException($key);
        }
    }
202362
public function setCoreCacheLexiconTopics($value)
    {
        $this->setFieldName('cache_lexicon_topics');
        $this->loadObject(true);
        $this->setFieldValue($value);

        return $this;
    }
183241
protected function setCache($cachename,$value,$expired){
        Cache::put($cachename,$value,$expired/60);
        return false;
    }
1102254
public function set( $path, $value )
	{
		$parts = explode( '/', trim( $path, '/' ) );

		$config = $this->_config;
		$max = count( $parts ) - 1;

		for( $i = 0; $i < $max; $i++ )
		{
			$val = $config->get( $parts[$i] );

			if( $val instanceof Zend_Config ) {
				$config = $val;
			} else {
				$config = $config->{$parts[$i]} = new Zend_Config( array(), true );
			}
		}

		$config->{$parts[$max]} = $value;
	}
692628
public function offsetSet($offset, $value) {
    if (NULL === $offset) {
      $this->container[] = [$value, NULL];
      return;
    }
    $this->container[$this->getHash($offset)] = [$value, $offset];
  }
1176764
public function offsetSet($offset, $value)
    {
        $this->ensureRootDirectory();

        list($url, $key) = $this->fileUrlAndKey($offset);

        $storage = $this->getOrCreateStorage($url);

        if ($key) {
            $storage->offsetSet($key, $value);
            return;
        }

        if (!is_array($value) && !$value instanceof \Traversable) {
            throw new UnsupportedParameterException("Setting values with a path depth of 1 must be array or Traversable");
        }

        $storage->clear();

        foreach ($value as $key=>$value) {
            $storage->offsetSet($key, $value);
        }

    }
1129438
public function offsetSet($offset, $value)
    {
        apc_store($this->getNamespace().'-class_'.$offset, $value);

        parent::offsetSet($offset, $value);
    }
336553
public function offsetSet($offset, $value)
    {
        $iterator = $this->getIterator();
        $iterator->offsetSet($offset, $value);

        // @codeCoverageIgnoreStart
    //
    // This method always throws an exception, so we ignore the closing
    // brace
    }
885866
protected function setCache($cachename,$value,$expired=0){
        $file = $this->cachedir . $cachename . '.cache';
        $data = array(
                'value' => $value,
                'expired' => $expired ? time() + $expired : 0
        );
        return file_put_contents( $file, serialize($data) ) ? true : false;
    }
828955
public function set($name, $value, $separator = '.')
    {
        static::setByPath($this->data, $name, $value, $separator);
    }
568416
public function set($resource, $value)
    {
        $path = $this->getSourcePath($resource);

        if (!is_dir($dir = dirname($path)) && false === @mkdir($dir, 0777, true)) {
            // @codeCoverageIgnoreStart
            throw new \RuntimeException('Unable to create directory '.$dir);
            // @codeCoverageIgnoreEnd
        }

        if (false === @file_put_contents($path, sprintf("<?php\n\n// $resource\nreturn %s;\n", var_export($value, true)))) {
            // @codeCoverageIgnoreStart
            throw new \RuntimeException('Unable to write file '.$path);
            // @codeCoverageIgnoreEnd
        }
    }
419018
public function set( $path, $value )
	{
		$path = trim( $path, '/' );

		$this->_getObject()->set( $path, $value );

		apc_store( $this->_prefix . $path, $value );
	}
562889
public function offsetSet($offset, $value)
    {
        $this->ensureDirectory($this->urlOrFail());

        $this->checkKey($offset);

        $fileUrl = $this->fileOfKey($offset);
        $hashMethod = $this->getOption('checksum_method');

        if (!$hashMethod) {
            $this->filesystem->write(
                $fileUrl,
                $this->serializer->serialize($value, $this->serializeOptions),
                $this->getOption('file_locking')
            );

            return;
        }

        $blob = $this->serializer->serialize($value, $this->serializeOptions);

        $this->filesystem->write(
                $fileUrl,
                $blob,
                $this->getOption('file_locking')
            );

        $checksum = $this->createChecksum($hashMethod, $blob);

        $savedBlob = $this->filesystem->read($fileUrl);

        $this->checkData($hashMethod, $savedBlob, $checksum);
    }
859189
public function setItem(
        $cacheId,
        $value
    ) {
        $path = $this->keyPath($cacheId);

        return FileUtils::write(
            $path,
            $this->compact($value)
        );
    }