{@inheritDoc}
@see \common_persistence_AdvKvDriver::hSet()
357758
public function hSet($key, $field, $value)
    {
        $this->log(__FUNCTION__, $key);
        return $this->persistence->hSet($key, $field, $value);
    }
780988
public static function mset($chunk, array $keys, $value) {
        $head = $chunk;
        $last = count($keys)-1;
        foreach($keys as $id => $key) {
            if ($last == $id) {
                if (is_null($value)) {
                    unset($chunk->$key);
                } else {
                    $chunk->$key = $value;
                }
            } else {
                $chunk->$key = isset($chunk->$key)? $chunk->$key : new stdClass();
                $chunk = $chunk->$key;
            }
        }
        return $head;
    }
159902
def hset(key, field, value, host=None, port=None, db=None, password=None):
    '''
    
    '''
    server = _connect(host, port, db, password)
    return server.hset(key, field, value)
1074015
public function set($key, $value)
    {
        // take care about replacing keys !
        if (is_resource($value) || $value instanceof StreamInterface) {
            $res = file_put_contents($this->filePath($key), $value);
            if ($res !== false) {
                // clear plain storage from key
                return $this->deleteStore($key);
            }
            return $res;
        } else {
            $this->storage[$key] = $value;
            $res = $this->save();
            if ($res !== false) {
                // clear file storage from key
                return $this->deleteFile($key);
            }
            return $res;
        }
    }
610647
function setPassword($pValue = '', $pAlreadyHashed = false) {
    	if (!$pAlreadyHashed) {
    		$pValue = PHPExcel_Shared_PasswordHasher::hashPassword($pValue);
    	}
		$this->_password = $pValue;
		return $this;
    }
448136
func (db *RedisDB) HSet(k, f, v string) {
	db.master.Lock()
	defer db.master.Unlock()
	db.hashSet(k, f, v)
}
689054
public function set($key, $value) {
        return ($this->redis->hSet($this->hash, $key, $value) !== false);
    }
1286046
public String hmset(Object key, Map<Object, Object> hash) {
		Jedis jedis = getJedis();
		try {
			Map<byte[], byte[]> para = new HashMap<byte[], byte[]>();
			for (Entry<Object, Object> e : hash.entrySet())
				para.put(fieldToBytes(e.getKey()), valueToBytes(e.getValue()));
			return jedis.hmset(keyToBytes(key), para);
		}
		finally {close(jedis);}
	}
772045
public function offsetSet($offset, $value)
    {
        if ($offset === null) {
            $offset = uniqid('uid');
        }
        if (is_string($value)) {
            $this->redis->hSet($this->key, $offset, "!".$value);
        } else {
            $this->redis->hSet($this->key, $offset, serialize($value));
        }
    }
536565
public function setSummaryHashState(string $hashState): self
    {
        $len = Util::strlen($hashState);
        if ($len !== 384 && $len !== 361) {
            throw new \RangeException(
                'Expected exactly 361 or 384 bytes, ' . $len . ' given.'
            );
        }
        $this->summaryHashState = $hashState;
        return $this;
    }
309195
public function mset($pairs)
    {
        $this->stopPipeline();
        foreach ($pairs as $key => $value) {
            $this->set($key, $value);
        }
        $this->restorePipeline();

        return $this->returnPipedInfo('OK');
    }
257903
public function mget(...$keys)
    {
        $keys = array_unique($this->prepareArguments('mget', ...$keys));
        $this->init();
        $values = [];
        foreach ($this->driver->mget($keys) as $value) {
            $values[] = $this->convertFalseToNull($value);
        }
        return array_combine($keys, $values);
    }
141930
public static function hashSet($name, $key, $value) {
        try {
            self::getCache()->hashSet($name, $key, $value);
            self::release();
        } catch (\RuntimeException $e) {
            self::release();
            throw $e;
        } catch (\Error $e) {
            self::release();
            throw $e;
        }
    }
713024
function multi_set($kvs = []) {
        $args = [];
        foreach ($kvs as $k => $v) {
            $args[] = $k;
            $args[] = $v;
        }

        return $this->__call(__FUNCTION__, $args);
    }
1136634
public function mget($keys){
		$this->queries_mget_count++;
		$r=array();
		foreach($keys as $key){
			$r[$key]=$this->get($key);
			}
		return $r;
		}
1119316
public static function set($key, $data, $lifetime = NULL, $group = NULL)
	{
		$result = FALSE;
		try {
			!self::classExists() or $result = self::instance($group)->set($key, $data, $lifetime);
		} catch (Cache_Exception $e) {
			self::exception($e);
		}

		return $result;
	}
1057344
static function Upper($text,$charset = null){
		static $TR_TABLES = array();

		$charset = self::_GetCharsetByName($charset);
		switch($charset){
			case "windows-1250":
			case "iso-8859-2":
				if(!isset($TR_TABLES[$charset])){
					require(dirname(__FILE__)."/tr_tables/lower_upper/$charset.php");
				}
				$text = strtr($text,$TR_TABLES[$charset]["mala"],$TR_TABLES[$charset]["velka"]);
				break;
			case "utf8":
				$text = mb_strtoupper($text,"utf8");
				break;
			case "ascii":
			default: 
				$text = strtoupper($text);
		}

		return $text;
	}