Name of the Redis hash to store queue messages.

@param redisHashName
@return
492075
public BaseRedisQueue<ID, DATA> setRedisHashName(String redisHashName) {
        _redisHashName = redisHashName;
        this.redisHashName = _redisHashName.getBytes(QueueUtils.UTF8);
        return this;
    }
1295433
def get_hash(name)
      if (item = dynamo_get_item(name))
        JSON.parse(item)
      else
        ::Hash.new
      end
    end
185612
function Queue (name, redisClient) {
  this.hasQuit = false
  this._name = name
  this.redisClient = redisClient
  this._key = Queue.PREFIX + this.name
}
1040172
def _get_dicts_from_redis(self, name, index_name, redis_prefix, item):
        
        r = self._redis
        data_dict = {}
        data_index_dict = {}

        if redis_prefix is None:
            raise KeyError ("redis_prefix is missing")

        if r.scard(redis_prefix + index_name + str(item)) > 0:
            data_index_dict[str(item)] = r.smembers(redis_prefix + index_name + str(item))

            for i in data_index_dict[item]:
                json_data = r.get(redis_prefix + name + str(int(i)))
                data_dict[i] = self._deserialize_data(json_data)

            return (data_dict, data_index_dict)

        raise KeyError ("No Data found in Redis for "+ item)
1208356
def hkeys(self, name):
        
        with self.pipe as pipe:
            f = Future()
            res = pipe.hkeys(self.redis_key(name))

            def cb():
                m_decode = self.memberparse.decode
                f.set([m_decode(v) for v in res.result])

            pipe.on_execute(cb)
            return f
191124
public static byte[] getMerkleRootHash(Queue<byte[]> hashQueue,
		@NonNull HashAlgorithm algorithm)
	{
		while (hashQueue.size() > 1)
		{
			byte[] hashValue = ArrayUtils.addAll(hashQueue.poll(), hashQueue.poll());
			switch (algorithm)
			{
				case SHA1 :
					hashQueue.add(DigestUtils.sha1(hashValue));
				case SHA256 :
					hashQueue.add(DigestUtils.sha256(hashValue));
				case SHA384 :
					hashQueue.add(DigestUtils.sha384(hashValue));
				case SHA512 :
					hashQueue.add(DigestUtils.sha512(hashValue));
				case SHA_1 :
					hashQueue.add(DigestUtils.sha1(hashValue));
				case SHA_256 :
					hashQueue.add(DigestUtils.sha256(hashValue));
				case SHA_384 :
					hashQueue.add(DigestUtils.sha384(hashValue));
				case SHA_512 :
					hashQueue.add(DigestUtils.sha512(hashValue));
				default :
					hashQueue.add(DigestUtils.sha256(hashValue));
			}
		}
		return hashQueue.poll();
	}
850064
protected Message lookupMessage(String queueName)  {
        checkStarted();

        try(Session session = consumerConnection.createSession()) {
            Queue queue = (Queue) jmsServer.lookup(QUEUE_NAMESPACE + queueName);
            Enumeration messages = session.createBrowser(queue).getEnumeration();
            return (Message) messages.nextElement();
        }catch (NoSuchElementException e){
            return null;
        }
        catch (Exception e) {
            throw new AsyncException("Lookup failed", e);
        }
    }
1136398
def load_hash_configuration(self, hash_name):
        
        conf = self.redis_object.get(hash_name+'_conf')

        return pickle.loads(conf) if conf is not None else None
519093
public byte []
hashName(Name name) throws NoSuchAlgorithmException
{
	return NSEC3Record.hashName(name, hashAlg, iterations, salt);
}
1122722
public static QueueName getQueueName(String appName, String flowName,
                                       byte[] rowBuffer, int rowOffset, int rowLength) {
    // Entry key is always (salt bytes + 1 MD5 byte + queueName + longWritePointer + intCounter)
    int queueNameEnd = rowOffset + rowLength - Bytes.SIZEOF_LONG - Bytes.SIZEOF_INT;

    // <flowlet><source>
    byte[] idWithinFlow = Arrays.copyOfRange(rowBuffer,
                                             rowOffset + HBaseQueueAdmin.SALT_BYTES + 1,
                                             queueNameEnd);
    String idWithinFlowAsString = new String(idWithinFlow, Charsets.US_ASCII);
    // <flowlet><source>
    String[] parts = idWithinFlowAsString.split("/");

    return QueueName.fromFlowlet(appName, flowName, parts[0], parts[1]);
  }
585098
def get(*args)
      if args.size == 1 && args[0].is_a?(Hash)
        queue_name = (args[0][:name] || args[0]['name']).to_s
        queue_name.empty? ? super : queues_get(queue_name)
      else
        super
      end
    end
1334271
@SuppressWarnings("deprecation")
	public final static HashFunction forName(final String messageDigest) throws NoSuchAlgorithmException {
		if ("".equals(messageDigest)) return null;
		if ("MD5".equalsIgnoreCase(messageDigest)) return Hashing.md5();
		if ("MurmurHash3".equalsIgnoreCase(messageDigest)) return Hashing.murmur3_128();
		throw new NoSuchAlgorithmException("Unknown hash function " + messageDigest);
	}
1153670
def to_h
      h = RRRSpec.redis.hgetall(key)
      h['trials'] = trials.map { |trial| { 'key' => trial.key } }
      h['key'] = key
      h['log'] = log
      h
    end
127529
@Deprecated
  private static ArrayList<FrequencyTableEntry> hashToFreqEntries(
      HashMap<String, ArrayList<Integer>> hash) {
    ArrayList<FrequencyTableEntry> res = new ArrayList<FrequencyTableEntry>();
    for (Entry<String, ArrayList<Integer>> e : hash.entrySet()) {
      char[] payload = e.getKey().toCharArray();
      int frequency = e.getValue().size();
      for (Integer i : e.getValue()) {
        res.add(new FrequencyTableEntry(i, payload.clone(), frequency));
      }
    }
    return res;
  }
1104025
def save
      mention_name = metadata[:mention_name] || metadata["mention_name"]

      current_keys = metadata.keys
      redis_keys = redis.hkeys("id:#{id}")
      delete_keys = (redis_keys - current_keys)

      redis.pipelined do
        redis.hdel("id:#{id}", *delete_keys) if delete_keys.any?
        redis.hmset("id:#{id}", *metadata.to_a.flatten)
        redis.set("name:#{name}", id)
        redis.set("mention_name:#{mention_name}", id) if mention_name
      end
    end
704260
@Nullable
  public IPasswordHashCreator getPasswordHashCreatorOfAlgorithm (@Nullable final String sAlgorithmName)
  {
    return m_aRWLock.readLocked ( () -> m_aPasswordHashCreators.get (sAlgorithmName));
  }
267498
def hash_name(self):
        
        name = self._item.get("market_hash_name")

        if not name:
            name = "{0.appid}-{0.name}".format(self)

        return name