Name of the Redis list to store queue message ids.

@param redisListName
@return
967157
public BaseRedisQueue<ID, DATA> setRedisListName(String redisListName) {
        _redisListName = redisListName;
        this.redisListName = _redisListName.getBytes(QueueUtils.UTF8);
        return this;
    }
793022
public static function getList(string $name, int $index): string
    {
        $obj = new RedisList(self::handle(), $name);
        return $obj->get($index);
    }
662457
@Nonnull
  public ICommonsList <String> getHeaders (@Nullable final String sName)
  {
    return new CommonsArrayList <> (m_aHeaders.get (_unifyHeaderName (sName)));
  }
3637
def get_queues(*queue_names, **kwargs):
    
    from .settings import QUEUES

    if len(queue_names) <= 1:
        # Return "default" queue if no queue name is specified
        # or one queue with specified name
        return [get_queue(*queue_names, **kwargs)]

    # will return more than one queue
    # import job class only once for all queues
    kwargs['job_class'] = get_job_class(kwargs.pop('job_class', None))

    queue_params = QUEUES[queue_names[0]]
    connection_params = filter_connection_params(queue_params)
    queues = [get_queue(queue_names[0], **kwargs)]

    # do consistency checks while building return list
    for name in queue_names[1:]:
        queue = get_queue(name, **kwargs)
        if type(queue) is not type(queues[0]):
            raise ValueError(
                'Queues must have the same class.'
                '"{0}" and "{1}" have '
                'different classes'.format(name, queue_names[0]))
        if connection_params != filter_connection_params(QUEUES[name]):
            raise ValueError(
                'Queues must have the same redis connection.'
                '"{0}" and "{1}" have '
                'different connections'.format(name, queue_names[0]))
        queues.append(queue)

    return queues
79369
def get_redis_storage(data_type, full_name, args = {})
      self.class.redis_ping!
      case data_type.to_sym
      when :array
        Redis::List.new(full_name, {:marshal => true}.merge(args))
      when :hash
        Redis::HashKey.new(full_name)
      when :value
        Redis::Value.new(full_name, {:marshal => true}.merge(args))
      when :lock
        Redis::Lock.new(full_name, {:expiration => 60, :timeout => 0.1}.merge(args))
      when :stamped
        Stamped.new(full_name.sub("#{key}_", "").to_sym, get_redis_storage(:value, full_name), self)
      else
        raise TypeError.new("Unsupported caching data type encountered: #{data_type}")
      end
    end
805990
def llen(self, name):
        
        with self.pipe as pipe:
            return pipe.llen(self.redis_key(name))
275225
public ConnectionFactory getConnectionFactory(String queueName)
    {
        // このメソッドを呼び出す前に、
        // this#initContextMap()を利用してcontextMapを初期しておくこと。 
        if (this.contextMap == null)
        {
            return null;
        }

        RabbitmqClusterContext context = this.contextMap.get(queueName);
        if (context == null)
        {
            return null;
        }

        return context.getConnectionFactory();
    }
715821
public static void checkQueueName( String queueName ) throws JMSException
    {
        if (queueName == null)
            throw new FFMQException("Queue name is not set","INVALID_DESTINATION_NAME");            
        if (queueName.length() > FFMQConstants.MAX_QUEUE_NAME_SIZE)
            throw new FFMQException("Queue name '"+queueName+"' is too long ("+queueName.length()+" > "+FFMQConstants.MAX_QUEUE_NAME_SIZE+")","INVALID_DESTINATION_NAME");
        checkDestinationName(queueName);
    }
1038600
public static ArrayList<QueueModel> getQueues(Client client) throws IOException {
        return getQueues(client, null, null, null);
    }
905202
@Override
  public List<String> listBucketNames()
      throws IOException {
    logger.atFine().log("listBucketNames()");
    List<Bucket> allBuckets = listBucketsInternal();
    List<String> bucketNames = new ArrayList<>(allBuckets.size());
    for (Bucket bucket : allBuckets) {
      bucketNames.add(bucket.getName());
    }
    return bucketNames;
  }
277871
public java.util.List<String> getIds() {
        if (ids == null) {
            ids = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return ids;
    }
548721
def queue(self):
        """"""
        if not self.include_rq:
            return None
        ctx = stack.top
        if ctx is not None:
            if not hasattr(ctx, 'redislite_queue'):
                ctx.redislite_queue = {}

                for queue_name in self.queues:
                    ctx.redislite_queue[queue_name] = \
                        Queue(queue_name, connection=self.connection)

            return ctx.redislite_queue
1166982
def hlen(self, name):
        
        with self.pipe as pipe:
            return pipe.hlen(self.redis_key(name))
873931
public java.util.List<String> getHsmList() {
        if (hsmList == null) {
            hsmList = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return hsmList;
    }
846116
public Collection<String> getNames() {
		Collection<String> names = new HashSet<String>();
		for (InitParam initParam : initParams) {
			names.add(initParam.getName());
		}
		return names;
	}
470904
public List<RedisClient> getAliveClients(Object key) {
        List<RedisClient> aliveClients = new ArrayList<RedisClient>();
        for (RedisClient redisClient : clientList) {
            if (redisClient.isAlive()) {
                aliveClients.add(redisClient);
            }
        }
        return aliveClients;
    }
445164
public java.util.List<DeleteClusterSnapshotMessage> getIdentifiers() {
        if (identifiers == null) {
            identifiers = new com.amazonaws.internal.SdkInternalList<DeleteClusterSnapshotMessage>();
        }
        return identifiers;
    }