Uses of Class
redis.clients.jedis.Response

Packages that use Response

redis.clients.jedis

Uses of Response in redis.clients.jedis

Methods in redis.clients.jedis that return Response

Response<Long>	BinaryRedisPipeline.append(byte[] key, byte[] value)
Response<Long>	RedisPipeline.append(String key, String value)
Response<String>	BasicRedisPipeline.bgrewriteaof()
Response<String>	BasicRedisPipeline.bgsave()
Response<Long>	BinaryRedisPipeline.bitcount(byte[] key)
Response<Long>	BinaryRedisPipeline.bitcount(byte[] key, long start, long end)
Response<Long>	RedisPipeline.bitcount(String key)
Response<Long>	RedisPipeline.bitcount(String key, long start, long end)
Response<Long>	MultiKeyBinaryRedisPipeline.bitop(BitOP op, byte[] destKey, byte[]... srcKeys)
Response<Long>	MultiKeyCommandsPipeline.bitop(BitOP op, String destKey, String... srcKeys)
Response<List<byte[]>>	MultiKeyBinaryRedisPipeline.blpop(byte[]... args)
Response<List<byte[]>>	BinaryRedisPipeline.blpop(byte[] arg)
Response<List<String>>	MultiKeyCommandsPipeline.blpop(String... args)
Response<List<String>>	RedisPipeline.blpop(String arg)
Response<List<byte[]>>	MultiKeyBinaryRedisPipeline.brpop(byte[]... args)
Response<List<byte[]>>	BinaryRedisPipeline.brpop(byte[] arg)
Response<List<String>>	MultiKeyCommandsPipeline.brpop(String... args)
Response<List<String>>	RedisPipeline.brpop(String arg)
Response<byte[]>	MultiKeyBinaryRedisPipeline.brpoplpush(byte[] source, byte[] destination, int timeout)
Response<String>	MultiKeyCommandsPipeline.brpoplpush(String source, String destination, int timeout)
Response<String>	ClusterPipeline.clusterAddSlots(int... slots)
Response<String>	ClusterPipeline.clusterDelSlots(int... slots)
Response<List<String>>	ClusterPipeline.clusterGetKeysInSlot(int slot, int count)
Response<String>	ClusterPipeline.clusterInfo()
Response<String>	ClusterPipeline.clusterMeet(String ip, int port)
Response<String>	ClusterPipeline.clusterNodes()
Response<String>	ClusterPipeline.clusterSetSlotImporting(int slot, String nodeId)
Response<String>	ClusterPipeline.clusterSetSlotMigrating(int slot, String nodeId)
Response<String>	ClusterPipeline.clusterSetSlotNode(int slot, String nodeId)
Response<String>	BasicRedisPipeline.configGet(String pattern)
Response<String>	BasicRedisPipeline.configResetStat()
Response<String>	BasicRedisPipeline.configSet(String parameter, String value)
Response<Long>	BasicRedisPipeline.dbSize()
Response<Long>	BinaryRedisPipeline.decr(byte[] key)
Response<Long>	RedisPipeline.decr(String key)
Response<Long>	BinaryRedisPipeline.decrBy(byte[] key, long integer)
Response<Long>	RedisPipeline.decrBy(String key, long integer)
Response<Long>	MultiKeyBinaryRedisPipeline.del(byte[]... keys)
Response<Long>	BinaryRedisPipeline.del(byte[] keys)
Response<Long>	MultiKeyCommandsPipeline.del(String... keys)
Response<Long>	RedisPipeline.del(String key)
Response<String>	Pipeline.discard()
Response<byte[]>	BinaryRedisPipeline.echo(byte[] string)
Response<String>	RedisPipeline.echo(String string)
Response<List<Object>>	Pipeline.exec()
Response<Boolean>	BinaryRedisPipeline.exists(byte[] key)
Response<Boolean>	RedisPipeline.exists(String key)
Response<Long>	BinaryRedisPipeline.expire(byte[] key, int seconds)
Response<Long>	RedisPipeline.expire(String key, int seconds)
Response<Long>	BinaryRedisPipeline.expireAt(byte[] key, long unixTime)
Response<Long>	RedisPipeline.expireAt(String key, long unixTime)
Response<String>	BasicRedisPipeline.flushAll()
Response<String>	BasicRedisPipeline.flushDB()
protected Response<?>	Queable.generateResponse(Object data)
Response<byte[]>	BinaryRedisPipeline.get(byte[] key)
Response<String>	RedisPipeline.get(String key)
Response<Boolean>	BinaryRedisPipeline.getbit(byte[] key, long offset)
Response<Boolean>	RedisPipeline.getbit(String key, long offset)
Response<Long>	BinaryRedisPipeline.getrange(byte[] key, long startOffset, long endOffset)
Response<String>	RedisPipeline.getrange(String key, long startOffset, long endOffset)
protected <T> Response<T>	Queable.getResponse(Builder<T> builder)
protected <T> Response<T>	Pipeline.getResponse(Builder<T> builder)
Response<byte[]>	BinaryRedisPipeline.getSet(byte[] key, byte[] value)
Response<String>	RedisPipeline.getSet(String key, String value)
Response<Long>	BinaryRedisPipeline.hdel(byte[] key, byte[]... field)
Response<Long>	RedisPipeline.hdel(String key, String... field)
Response<Boolean>	BinaryRedisPipeline.hexists(byte[] key, byte[] field)
Response<Boolean>	RedisPipeline.hexists(String key, String field)
Response<byte[]>	BinaryRedisPipeline.hget(byte[] key, byte[] field)
Response<String>	RedisPipeline.hget(String key, String field)
Response<Map<byte[],byte[]>>	BinaryRedisPipeline.hgetAll(byte[] key)
Response<Map<String,String>>	RedisPipeline.hgetAll(String key)
Response<Long>	BinaryRedisPipeline.hincrBy(byte[] key, byte[] field, long value)
Response<Long>	RedisPipeline.hincrBy(String key, String field, long value)
Response<Set<byte[]>>	BinaryRedisPipeline.hkeys(byte[] key)
Response<Set<String>>	RedisPipeline.hkeys(String key)
Response<Long>	BinaryRedisPipeline.hlen(byte[] key)
Response<Long>	RedisPipeline.hlen(String key)
Response<List<byte[]>>	BinaryRedisPipeline.hmget(byte[] key, byte[]... fields)
Response<List<String>>	RedisPipeline.hmget(String key, String... fields)
Response<String>	BinaryRedisPipeline.hmset(byte[] key, Map<byte[],byte[]> hash)
Response<String>	RedisPipeline.hmset(String key, Map<String,String> hash)
Response<Long>	BinaryRedisPipeline.hset(byte[] key, byte[] field, byte[] value)
Response<Long>	RedisPipeline.hset(String key, String field, String value)
Response<Long>	BinaryRedisPipeline.hsetnx(byte[] key, byte[] field, byte[] value)
Response<Long>	RedisPipeline.hsetnx(String key, String field, String value)
Response<List<byte[]>>	BinaryRedisPipeline.hvals(byte[] key)
Response<List<String>>	RedisPipeline.hvals(String key)
Response<Long>	BinaryRedisPipeline.incr(byte[] key)
Response<Long>	RedisPipeline.incr(String key)
Response<Long>	BinaryRedisPipeline.incrBy(byte[] key, long integer)
Response<Long>	RedisPipeline.incrBy(String key, long integer)
Response<String>	BasicRedisPipeline.info()
Response<Set<byte[]>>	MultiKeyBinaryRedisPipeline.keys(byte[] pattern)
Response<Set<String>>	MultiKeyCommandsPipeline.keys(String pattern)
Response<Long>	BasicRedisPipeline.lastsave()
Response<byte[]>	BinaryRedisPipeline.lindex(byte[] key, long index)
Response<String>	RedisPipeline.lindex(String key, long index)
Response<Long>	BinaryRedisPipeline.linsert(byte[] key, BinaryClient.LIST_POSITION where, byte[] pivot, byte[] value)
Response<Long>	RedisPipeline.linsert(String key, BinaryClient.LIST_POSITION where, String pivot, String value)
Response<Long>	BinaryRedisPipeline.llen(byte[] key)
Response<Long>	RedisPipeline.llen(String key)
Response<byte[]>	BinaryRedisPipeline.lpop(byte[] key)
Response<String>	RedisPipeline.lpop(String key)
Response<Long>	BinaryRedisPipeline.lpush(byte[] key, byte[]... string)
Response<Long>	RedisPipeline.lpush(String key, String... string)
Response<Long>	BinaryRedisPipeline.lpushx(byte[] key, byte[]... bytes)
Response<Long>	RedisPipeline.lpushx(String key, String... string)
Response<List<byte[]>>	BinaryRedisPipeline.lrange(byte[] key, long start, long end)
Response<List<String>>	RedisPipeline.lrange(String key, long start, long end)
Response<Long>	BinaryRedisPipeline.lrem(byte[] key, long count, byte[] value)
Response<Long>	RedisPipeline.lrem(String key, long count, String value)
Response<String>	BinaryRedisPipeline.lset(byte[] key, long index, byte[] value)
Response<String>	RedisPipeline.lset(String key, long index, String value)
Response<String>	BinaryRedisPipeline.ltrim(byte[] key, long start, long end)
Response<String>	RedisPipeline.ltrim(String key, long start, long end)
Response<List<byte[]>>	MultiKeyBinaryRedisPipeline.mget(byte[]... keys)
Response<List<String>>	MultiKeyCommandsPipeline.mget(String... keys)
Response<Long>	BinaryRedisPipeline.move(byte[] key, int dbIndex)
Response<Long>	RedisPipeline.move(String key, int dbIndex)
Response<String>	MultiKeyBinaryRedisPipeline.mset(byte[]... keysvalues)
Response<String>	MultiKeyCommandsPipeline.mset(String... keysvalues)
Response<Long>	MultiKeyBinaryRedisPipeline.msetnx(byte[]... keysvalues)
Response<Long>	MultiKeyCommandsPipeline.msetnx(String... keysvalues)
Response<String>	Pipeline.multi()
Response<Long>	BinaryRedisPipeline.persist(byte[] key)
Response<Long>	RedisPipeline.persist(String key)
Response<Long>	BinaryRedisPipeline.pfadd(byte[] key, byte[]... elements)
Response<Long>	RedisPipeline.pfadd(String key, String... elements)
Response<Long>	MultiKeyBinaryRedisPipeline.pfcount(byte[]... keys)
Response<Long>	BinaryRedisPipeline.pfcount(byte[] key)
Response<Long>	MultiKeyCommandsPipeline.pfcount(String... keys)
Response<Long>	RedisPipeline.pfcount(String key)
Response<String>	MultiKeyBinaryRedisPipeline.pfmerge(byte[] destkey, byte[]... sourcekeys)
Response<String>	MultiKeyCommandsPipeline.pfmerge(String destkey, String... sourcekeys)
Response<String>	BasicRedisPipeline.ping()
Response<Long>	MultiKeyBinaryRedisPipeline.publish(byte[] channel, byte[] message)
Response<Long>	MultiKeyCommandsPipeline.publish(String channel, String message)
Response<String>	MultiKeyCommandsPipeline.randomKey()
Response<byte[]>	MultiKeyBinaryRedisPipeline.randomKeyBinary()
Response<String>	MultiKeyBinaryRedisPipeline.rename(byte[] oldkey, byte[] newkey)
Response<String>	MultiKeyCommandsPipeline.rename(String oldkey, String newkey)
Response<Long>	MultiKeyBinaryRedisPipeline.renamenx(byte[] oldkey, byte[] newkey)
Response<Long>	MultiKeyCommandsPipeline.renamenx(String oldkey, String newkey)
Response<byte[]>	BinaryRedisPipeline.rpop(byte[] key)
Response<String>	RedisPipeline.rpop(String key)
Response<byte[]>	MultiKeyBinaryRedisPipeline.rpoplpush(byte[] srckey, byte[] dstkey)
Response<String>	MultiKeyCommandsPipeline.rpoplpush(String srckey, String dstkey)
Response<Long>	BinaryRedisPipeline.rpush(byte[] key, byte[]... string)
Response<Long>	RedisPipeline.rpush(String key, String... string)
Response<Long>	BinaryRedisPipeline.rpushx(byte[] key, byte[]... string)
Response<Long>	RedisPipeline.rpushx(String key, String... string)
Response<Long>	BinaryRedisPipeline.sadd(byte[] key, byte[]... member)
Response<Long>	RedisPipeline.sadd(String key, String... member)
Response<String>	BasicRedisPipeline.save()
Response<Long>	BinaryRedisPipeline.scard(byte[] key)
Response<Long>	RedisPipeline.scard(String key)
Response<Set<byte[]>>	MultiKeyBinaryRedisPipeline.sdiff(byte[]... keys)
Response<Set<String>>	MultiKeyCommandsPipeline.sdiff(String... keys)
Response<Long>	MultiKeyBinaryRedisPipeline.sdiffstore(byte[] dstkey, byte[]... keys)
Response<Long>	MultiKeyCommandsPipeline.sdiffstore(String dstkey, String... keys)
Response<String>	BasicRedisPipeline.select(int index)
Response<String>	BinaryRedisPipeline.set(byte[] key, byte[] value)
Response<String>	RedisPipeline.set(String key, String value)
Response<Boolean>	BinaryRedisPipeline.setbit(byte[] key, long offset, byte[] value)
Response<Boolean>	RedisPipeline.setbit(String key, long offset, boolean value)
Response<String>	BinaryRedisPipeline.setex(byte[] key, int seconds, byte[] value)
Response<String>	RedisPipeline.setex(String key, int seconds, String value)
Response<Long>	BinaryRedisPipeline.setnx(byte[] key, byte[] value)
Response<Long>	RedisPipeline.setnx(String key, String value)
Response<Long>	BinaryRedisPipeline.setrange(byte[] key, long offset, byte[] value)
Response<Long>	RedisPipeline.setrange(String key, long offset, String value)
Response<Long>	BinaryRedisPipeline.setrange(String key, long offset, String value)
Response<String>	BasicRedisPipeline.shutdown()
Response<Set<byte[]>>	MultiKeyBinaryRedisPipeline.sinter(byte[]... keys)
Response<Set<String>>	MultiKeyCommandsPipeline.sinter(String... keys)
Response<Long>	MultiKeyBinaryRedisPipeline.sinterstore(byte[] dstkey, byte[]... keys)
Response<Long>	MultiKeyCommandsPipeline.sinterstore(String dstkey, String... keys)
Response<Boolean>	BinaryRedisPipeline.sismember(byte[] key, byte[] member)
Response<Boolean>	RedisPipeline.sismember(String key, String member)
Response<Set<byte[]>>	BinaryRedisPipeline.smembers(byte[] key)
Response<Set<String>>	RedisPipeline.smembers(String key)
Response<Long>	MultiKeyBinaryRedisPipeline.smove(byte[] srckey, byte[] dstkey, byte[] member)
Response<Long>	MultiKeyCommandsPipeline.smove(String srckey, String dstkey, String member)
Response<List<byte[]>>	BinaryRedisPipeline.sort(byte[] key)
Response<Long>	MultiKeyBinaryRedisPipeline.sort(byte[] key, byte[] dstkey)
Response<List<byte[]>>	BinaryRedisPipeline.sort(byte[] key, SortingParams sortingParameters)
Response<Long>	MultiKeyBinaryRedisPipeline.sort(byte[] key, SortingParams sortingParameters, byte[] dstkey)
Response<List<String>>	RedisPipeline.sort(String key)
Response<List<String>>	RedisPipeline.sort(String key, SortingParams sortingParameters)
Response<Long>	MultiKeyCommandsPipeline.sort(String key, SortingParams sortingParameters, String dstkey)
Response<Long>	MultiKeyCommandsPipeline.sort(String key, String dstkey)
Response<byte[]>	BinaryRedisPipeline.spop(byte[] key)
Response<String>	RedisPipeline.spop(String key)
Response<byte[]>	BinaryRedisPipeline.srandmember(byte[] key)
Response<String>	RedisPipeline.srandmember(String key)
Response<Long>	BinaryRedisPipeline.srem(byte[] key, byte[]... member)
Response<Long>	RedisPipeline.srem(String key, String... member)
Response<Long>	BinaryRedisPipeline.strlen(byte[] key)
Response<Long>	RedisPipeline.strlen(String key)
Response<String>	BinaryRedisPipeline.substr(byte[] key, int start, int end)
Response<String>	RedisPipeline.substr(String key, int start, int end)
Response<Set<byte[]>>	MultiKeyBinaryRedisPipeline.sunion(byte[]... keys)
Response<Set<String>>	MultiKeyCommandsPipeline.sunion(String... keys)
Response<Long>	MultiKeyBinaryRedisPipeline.sunionstore(byte[] dstkey, byte[]... keys)
Response<Long>	MultiKeyCommandsPipeline.sunionstore(String dstkey, String... keys)
Response<List<String>>	BasicRedisPipeline.time()
Response<Long>	BinaryRedisPipeline.ttl(byte[] key)
Response<Long>	RedisPipeline.ttl(String key)
Response<String>	BinaryRedisPipeline.type(byte[] key)
Response<String>	RedisPipeline.type(String key)
Response<String>	MultiKeyBinaryRedisPipeline.watch(byte[]... keys)
Response<String>	MultiKeyCommandsPipeline.watch(String... keys)
Response<Long>	BinaryRedisPipeline.zadd(byte[] key, double score, byte[] member)
Response<Long>	RedisPipeline.zadd(String key, double score, String member)
Response<Long>	BinaryRedisPipeline.zcard(byte[] key)
Response<Long>	RedisPipeline.zcard(String key)
Response<Long>	BinaryRedisPipeline.zcount(byte[] key, double min, double max)
Response<Long>	RedisPipeline.zcount(String key, double min, double max)
Response<Double>	BinaryRedisPipeline.zincrby(byte[] key, double score, byte[] member)
Response<Double>	RedisPipeline.zincrby(String key, double score, String member)
Response<Long>	MultiKeyBinaryRedisPipeline.zinterstore(byte[] dstkey, byte[]... sets)
Response<Long>	MultiKeyBinaryRedisPipeline.zinterstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Long>	MultiKeyCommandsPipeline.zinterstore(String dstkey, String... sets)
Response<Long>	MultiKeyCommandsPipeline.zinterstore(String dstkey, ZParams params, String... sets)
Response<Long>	BinaryRedisPipeline.zlexcount(byte[] key, byte[] min, byte[] max)
Response<Long>	RedisPipeline.zlexcount(String key, String min, String max)
Response<Set<byte[]>>	BinaryRedisPipeline.zrange(byte[] key, long start, long end)
Response<Set<String>>	RedisPipeline.zrange(String key, long start, long end)
Response<Set<byte[]>>	BinaryRedisPipeline.zrangeByLex(byte[] key, byte[] max, byte[] min)
Response<Set<byte[]>>	BinaryRedisPipeline.zrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<Set<String>>	RedisPipeline.zrangeByLex(String key, String max, String min)
Response<Set<String>>	RedisPipeline.zrangeByLex(String key, String max, String min, int offset, int count)
Response<Set<byte[]>>	BinaryRedisPipeline.zrangeByScore(byte[] key, byte[] min, byte[] max)
Response<Set<byte[]>>	BinaryRedisPipeline.zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<Set<byte[]>>	BinaryRedisPipeline.zrangeByScore(byte[] key, double min, double max)
Response<Set<byte[]>>	BinaryRedisPipeline.zrangeByScore(byte[] key, double min, double max, int offset, int count)
Response<Set<String>>	RedisPipeline.zrangeByScore(String key, double min, double max)
Response<Set<String>>	RedisPipeline.zrangeByScore(String key, double min, double max, int offset, int count)
Response<Set<String>>	RedisPipeline.zrangeByScore(String key, String min, String max)
Response<Set<Tuple>>	BinaryRedisPipeline.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Response<Set<Tuple>>	BinaryRedisPipeline.zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<Set<Tuple>>	BinaryRedisPipeline.zrangeByScoreWithScores(byte[] key, double min, double max)
Response<Set<Tuple>>	BinaryRedisPipeline.zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Response<Set<Tuple>>	RedisPipeline.zrangeByScoreWithScores(String key, double min, double max)
Response<Set<Tuple>>	RedisPipeline.zrangeByScoreWithScores(String key, double min, double max, int offset, int count)
Response<Set<Tuple>>	BinaryRedisPipeline.zrangeWithScores(byte[] key, long start, long end)
Response<Set<Tuple>>	RedisPipeline.zrangeWithScores(String key, long start, long end)
Response<Long>	BinaryRedisPipeline.zrank(byte[] key, byte[] member)
Response<Long>	RedisPipeline.zrank(String key, String member)
Response<Long>	BinaryRedisPipeline.zrem(byte[] key, byte[]... member)
Response<Long>	RedisPipeline.zrem(String key, String... member)
Response<Long>	BinaryRedisPipeline.zremrangeByLex(byte[] key, byte[] min, byte[] max)
Response<Long>	RedisPipeline.zremrangeByLex(String key, String start, String end)
Response<Long>	BinaryRedisPipeline.zremrangeByRank(byte[] key, long start, long end)
Response<Long>	RedisPipeline.zremrangeByRank(String key, long start, long end)
Response<Long>	BinaryRedisPipeline.zremrangeByScore(byte[] key, byte[] start, byte[] end)
Response<Long>	BinaryRedisPipeline.zremrangeByScore(byte[] key, double start, double end)
Response<Long>	RedisPipeline.zremrangeByScore(String key, double start, double end)
Response<Set<byte[]>>	BinaryRedisPipeline.zrevrange(byte[] key, long start, long end)
Response<Set<String>>	RedisPipeline.zrevrange(String key, long start, long end)
Response<Set<byte[]>>	BinaryRedisPipeline.zrevrangeByScore(byte[] key, byte[] max, byte[] min)
Response<Set<byte[]>>	BinaryRedisPipeline.zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<Set<byte[]>>	BinaryRedisPipeline.zrevrangeByScore(byte[] key, double max, double min)
Response<Set<byte[]>>	BinaryRedisPipeline.zrevrangeByScore(byte[] key, double max, double min, int offset, int count)
Response<Set<String>>	RedisPipeline.zrevrangeByScore(String key, double max, double min)
Response<Set<String>>	RedisPipeline.zrevrangeByScore(String key, double max, double min, int offset, int count)
Response<Set<String>>	RedisPipeline.zrevrangeByScore(String key, String max, String min)
Response<Set<Tuple>>	BinaryRedisPipeline.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Response<Set<Tuple>>	BinaryRedisPipeline.zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<Set<Tuple>>	BinaryRedisPipeline.zrevrangeByScoreWithScores(byte[] key, double max, double min)
Response<Set<Tuple>>	BinaryRedisPipeline.zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Response<Set<Tuple>>	RedisPipeline.zrevrangeByScoreWithScores(String key, double max, double min)
Response<Set<Tuple>>	RedisPipeline.zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
Response<Set<Tuple>>	BinaryRedisPipeline.zrevrangeWithScores(byte[] key, long start, long end)
Response<Set<Tuple>>	RedisPipeline.zrevrangeWithScores(String key, long start, long end)
Response<Long>	BinaryRedisPipeline.zrevrank(byte[] key, byte[] member)
Response<Long>	RedisPipeline.zrevrank(String key, String member)
Response<Double>	BinaryRedisPipeline.zscore(byte[] key, byte[] member)
Response<Double>	RedisPipeline.zscore(String key, String member)
Response<Long>	MultiKeyBinaryRedisPipeline.zunionstore(byte[] dstkey, byte[]... sets)
Response<Long>	MultiKeyBinaryRedisPipeline.zunionstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Long>	MultiKeyCommandsPipeline.zunionstore(String dstkey, String... sets)
Response<Long>	MultiKeyCommandsPipeline.zunionstore(String dstkey, ZParams params, String... sets)

Methods in redis.clients.jedis that return types with arguments of type Response

List<Response<?>>

Transaction.execGetResponse()

Methods in redis.clients.jedis with parameters of type Response

void	Response.setDependency(Response<?> dependency)