org.springframework.data.redis.connection.RedisZSetCommands$Limit.isUnlimited java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 SimpleDateFormat s =String pattern;new SimpleDateFormat(pattern)
String template;Locale locale;new SimpleDateFormat(template, locale)
new SimpleDateFormat()
Smart code suggestions by Codota
}

@Override
public Set<byte[]> zRangeByLex(byte[] key, Range range, Limit limit) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(range, "Range cannot be null for ZRANGEBYLEX.");
  Assert.notNull(limit, "Limit must not be null!");
  byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getMin(), JedisConverters.toBytes("-"));
  byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getMax(), JedisConverters.toBytes("+"));
  try {
    if (limit.isUnlimited()) {
      return connection.getCluster().zrangeByLex(key, min, max);
    }
    return connection.getCluster().zrangeByLex(key, min, max, limit.getOffset(), limit.getCount());
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

Assert.notNull(command.getRange(), "Range must not be null!");
boolean isLimited = command.getLimit().isPresent() && !command.getLimit().get().isUnlimited();

@Override
public Set<byte[]> zRevRangeByScore(byte[] key, Range range, Limit limit) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(range, "Range cannot be null for ZREVRANGEBYSCORE.");
  byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES);
  byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES);
  try {
    if (limit.isUnlimited()) {
      return connection.getCluster().zrevrangeByScore(key, max, min);
    }
    return connection.getCluster().zrevrangeByScore(key, max, min, limit.getOffset(), limit.getCount());
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

@Override
public Set<Tuple> zRevRangeByScoreWithScores(byte[] key, Range range, Limit limit) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(range, "Range cannot be null for ZREVRANGEBYSCOREWITHSCORES.");
  byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES);
  byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES);
  try {
    if (limit.isUnlimited()) {
      return JedisConverters.toTupleSet(connection.getCluster().zrevrangeByScoreWithScores(key, max, min));
    }
    return JedisConverters.toTupleSet(
        connection.getCluster().zrevrangeByScoreWithScores(key, max, min, limit.getOffset(), limit.getCount()));
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

  if (limit.isUnlimited()) {
    pipeline(
        connection.newLettuceResult(getAsyncConnection().zrangebyscore(key, LettuceConverters.toRange(range)),
  if (limit.isUnlimited()) {
    transaction(
        connection.newLettuceResult(getAsyncConnection().zrangebyscore(key, LettuceConverters.toRange(range)),
if (limit.isUnlimited()) {
  return LettuceConverters.toBytesSet(getConnection().zrangebyscore(key, LettuceConverters.toRange(range)));

  if (limit.isUnlimited()) {
    pipeline(connection.newLettuceResult(
        getAsyncConnection().zrevrangebyscoreWithScores(key, LettuceConverters.toRange(range)),
  if (limit.isUnlimited()) {
    transaction(connection.newLettuceResult(
        getAsyncConnection().zrevrangebyscoreWithScores(key, LettuceConverters.toRange(range)),
if (limit.isUnlimited()) {
  return LettuceConverters
      .toTupleSet(getConnection().zrevrangebyscoreWithScores(key, LettuceConverters.toRange(range)));

  if (limit.isUnlimited()) {
    pipeline(connection.newLettuceResult(
        getAsyncConnection().zrangebyscoreWithScores(key, LettuceConverters.toRange(range)),
  if (limit.isUnlimited()) {
    transaction(connection.newLettuceResult(
        getAsyncConnection().zrangebyscoreWithScores(key, LettuceConverters.toRange(range)),
if (limit.isUnlimited()) {
  return LettuceConverters
      .toTupleSet(getConnection().zrangebyscoreWithScores(key, LettuceConverters.toRange(range)));

  if (limit.isUnlimited()) {
    pipeline(
        connection.newLettuceResult(getAsyncConnection().zrevrangebyscore(key, LettuceConverters.toRange(range)),
  if (limit.isUnlimited()) {
    transaction(
        connection.newLettuceResult(getAsyncConnection().zrevrangebyscore(key, LettuceConverters.toRange(range)),
if (limit.isUnlimited()) {
  return LettuceConverters.toBytesSet(getConnection().zrevrangebyscore(key, LettuceConverters.toRange(range)));

@Override
public Flux<CommandResponse<ZRangeByLexCommand, Flux<ByteBuffer>>> zRangeByLex(
    Publisher<ZRangeByLexCommand> commands) {
  return connection.execute(cmd -> Flux.from(commands).concatMap(command -> {
    Assert.notNull(command.getKey(), "Destination key must not be null!");
    Flux<ByteBuffer> result;
    if (!command.getLimit().isUnlimited()) {
      if (ObjectUtils.nullSafeEquals(command.getDirection(), Direction.ASC)) {
        result = cmd.zrangebylex(command.getKey(), RangeConverter.toRange(command.getRange()),
            LettuceConverters.toLimit(command.getLimit()));
      } else {
        result = cmd.zrevrangebylex(command.getKey(), RangeConverter.toRange(command.getRange()),
            LettuceConverters.toLimit(command.getLimit()));
      }
    } else {
      if (ObjectUtils.nullSafeEquals(command.getDirection(), Direction.ASC)) {
        result = cmd.zrangebylex(command.getKey(), RangeConverter.toRange(command.getRange()));
      } else {
        result = cmd.zrevrangebylex(command.getKey(), RangeConverter.toRange(command.getRange()));
      }
    }
    return Mono.just(new CommandResponse<>(command, result));
  }));
}

@Override
public Set<byte[]> zRangeByLex(byte[] key, Range range, Limit limit) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(range, "Range cannot be null for ZRANGEBYLEX.");
  Assert.notNull(limit, "Limit must not be null!");
  byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getMin(), JedisConverters.toBytes("-"));
  byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getMax(), JedisConverters.toBytes("+"));
  try {
    if (limit.isUnlimited()) {
      return connection.getCluster().zrangeByLex(key, min, max);
    }
    return connection.getCluster().zrangeByLex(key, min, max, limit.getOffset(), limit.getCount());
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

@Override
public Set<byte[]> zRevRangeByScore(byte[] key, Range range, Limit limit) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(range, "Range cannot be null for ZREVRANGEBYSCORE.");
  byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES);
  byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES);
  try {
    if (limit.isUnlimited()) {
      return connection.getCluster().zrevrangeByScore(key, max, min);
    }
    return connection.getCluster().zrevrangeByScore(key, max, min, limit.getOffset(), limit.getCount());
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

@Override
public Set<byte[]> zRangeByScore(byte[] key, Range range, Limit limit) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(range, "Range cannot be null for ZRANGEBYSCORE.");
  byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES);
  byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES);
  try {
    if (limit.isUnlimited()) {
      return connection.getCluster().zrangeByScore(key, min, max);
    }
    return connection.getCluster().zrangeByScore(key, min, max, limit.getOffset(), limit.getCount());
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

@Override
public Set<byte[]> zRangeByLex(byte[] key, Range range, Limit limit) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(range, "Range cannot be null for ZRANGEBYLEX.");
  Assert.notNull(limit, "Limit must not be null!");
  byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getMin(), JedisConverters.toBytes("-"));
  byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getMax(), JedisConverters.toBytes("+"));
  try {
    if (limit.isUnlimited()) {
      return connection.getCluster().zrangeByLex(key, min, max);
    }
    return connection.getCluster().zrangeByLex(key, min, max, limit.getOffset(), limit.getCount());
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

@Override
public Set<byte[]> zRevRangeByScore(byte[] key, Range range, Limit limit) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(range, "Range cannot be null for ZREVRANGEBYSCORE.");
  byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES);
  byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES);
  try {
    if (limit.isUnlimited()) {
      return connection.getCluster().zrevrangeByScore(key, max, min);
    }
    return connection.getCluster().zrevrangeByScore(key, max, min, limit.getOffset(), limit.getCount());
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

@Override
public Set<byte[]> zRangeByScore(byte[] key, Range range, Limit limit) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(range, "Range cannot be null for ZRANGEBYSCORE.");
  byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES);
  byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES);
  try {
    if (limit.isUnlimited()) {
      return connection.getCluster().zrangeByScore(key, min, max);
    }
    return connection.getCluster().zrangeByScore(key, min, max, limit.getOffset(), limit.getCount());
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

@Override
public Set<Tuple> zRangeByScoreWithScores(byte[] key, Range range, Limit limit) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(range, "Range cannot be null for ZRANGEBYSCOREWITHSCORES.");
  byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES);
  byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES);
  try {
    if (limit.isUnlimited()) {
      return JedisConverters.toTupleSet(connection.getCluster().zrangeByScoreWithScores(key, min, max));
    }
    return JedisConverters.toTupleSet(
        connection.getCluster().zrangeByScoreWithScores(key, min, max, limit.getOffset(), limit.getCount()));
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

@Override
public Set<Tuple> zRangeByScoreWithScores(byte[] key, Range range, Limit limit) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(range, "Range cannot be null for ZRANGEBYSCOREWITHSCORES.");
  byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES);
  byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES);
  try {
    if (limit.isUnlimited()) {
      return JedisConverters.toTupleSet(connection.getCluster().zrangeByScoreWithScores(key, min, max));
    }
    return JedisConverters.toTupleSet(
        connection.getCluster().zrangeByScoreWithScores(key, min, max, limit.getOffset(), limit.getCount()));
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

@Override
public Set<Tuple> zRevRangeByScoreWithScores(byte[] key, Range range, Limit limit) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(range, "Range cannot be null for ZREVRANGEBYSCOREWITHSCORES.");
  byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES);
  byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES);
  try {
    if (limit.isUnlimited()) {
      return JedisConverters.toTupleSet(connection.getCluster().zrevrangeByScoreWithScores(key, max, min));
    }
    return JedisConverters.toTupleSet(
        connection.getCluster().zrevrangeByScoreWithScores(key, max, min, limit.getOffset(), limit.getCount()));
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

@Override
public Set<Tuple> zRangeByScoreWithScores(byte[] key, Range range, Limit limit) {
  Assert.notNull(key, "Key must not be null!");
  Assert.notNull(range, "Range cannot be null for ZRANGEBYSCOREWITHSCORES.");
  byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES);
  byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES);
  try {
    if (limit.isUnlimited()) {
      return JedisConverters.toTupleSet(connection.getCluster().zrangeByScoreWithScores(key, min, max));
    }
    return JedisConverters.toTupleSet(
        connection.getCluster().zrangeByScoreWithScores(key, min, max, limit.getOffset(), limit.getCount()));
  } catch (Exception ex) {
    throw convertJedisAccessException(ex);
  }
}

  if (limit.isUnlimited()) {
    pipeline(
        connection.newLettuceResult(getAsyncConnection().zrangebylex(key, LettuceConverters.toRange(range, true)),
  if (limit.isUnlimited()) {
    transaction(
        connection.newLettuceResult(getAsyncConnection().zrangebylex(key, LettuceConverters.toRange(range, true)),
if (limit.isUnlimited()) {
  return LettuceConverters.bytesListToBytesSet()
      .convert(getConnection().zrangebylex(key, LettuceConverters.toRange(range, true)));

Popular methods of RedisZSetCommands$Limit

Popular in Java

Finding current android device location
scheduleAtFixedRate (ScheduledExecutorService)
getSupportFragmentManager (FragmentActivity)
Return the FragmentManager for interacting with fragments associated with this activity.
getSystemService (Context)
Font (java.awt)
The Font class represents fonts, which are used to render text in a visible way. A font provides the
GridLayout (java.awt)
The GridLayout class is a layout manager that lays out a container's components in a rectangular gri
URI (java.net)
Represents a Uniform Resource Identifier (URI) reference. Aside from some minor deviations noted bel
Path (java.nio.file)
Set (java.util)
A collection that contains no duplicate elements. More formally, sets contain no pair of elements e1
Semaphore (java.util.concurrent)
A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each #acquire blocks if

How to use isUnlimitedmethodin org.springframework.data.redis.connection.RedisZSetCommands$Limit

Best Java code snippets using org.springframework.data.redis.connection.RedisZSetCommands$Limit.isUnlimited (Showing top 20 results out of 315)

How to use
isUnlimited
method
in
org.springframework.data.redis.connection.RedisZSetCommands$Limit