org.springframework.data.redis.core.ScanIteration java code examples

  @Override
  protected ScanIteration<Tuple> doScan(byte[] key, long cursorId, ScanOptions options) {
    if (isQueueing() || isPipelined()) {
      throw new UnsupportedOperationException("'ZSCAN' cannot be called in pipeline / transaction mode.");
    }
    List<Object> args = new ArrayList<Object>();
    args.add(key);
    args.add(cursorId);
    if (options.getPattern() != null) {
      args.add("MATCH");
      args.add(options.getPattern());
    }
    if (options.getCount() != null) {
      args.add("COUNT");
      args.add(options.getCount());
    }
    
    RFuture<ListScanResult<Tuple>> f = executorService.readAsync(client, key, ByteArrayCodec.INSTANCE, ZSCAN, args.toArray());
    ListScanResult<Tuple> res = syncFuture(f);
    client = res.getRedisClient();
    return new ScanIteration<Tuple>(res.getPos(), res.getValues());
  }
}.open();

private void processScanResult(ScanIteration<T> result) {
  if (result == null) {
    resetDelegate();
    state = CursorState.FINISHED;
    return;
  }
  cursorId = Long.valueOf(result.getCursorId());
  if (isFinished(cursorId)) {
    state = CursorState.FINISHED;
  }
  if (!CollectionUtils.isEmpty(result.getItems())) {
    delegate = result.iterator();
  } else {
    resetDelegate();
  }
}

  @Override
  protected ScanIteration<byte[]> doScan(byte[] key, long cursorId, ScanOptions options) {
    if (isQueueing() || isPipelined()) {
      throw new UnsupportedOperationException("'SSCAN' cannot be called in pipeline / transaction mode.");
    }
    List<Object> args = new ArrayList<Object>();
    args.add(key);
    args.add(cursorId);
    if (options.getPattern() != null) {
      args.add("MATCH");
      args.add(options.getPattern());
    }
    if (options.getCount() != null) {
      args.add("COUNT");
      args.add(options.getCount());
    }
    
    RFuture<ListScanResult<byte[]>> f = executorService.readAsync(client, key, ByteArrayCodec.INSTANCE, RedisCommands.SSCAN, args.toArray());
    ListScanResult<byte[]> res = syncFuture(f);
    client = res.getRedisClient();
    return new ScanIteration<byte[]>(res.getPos(), res.getValues());
  }
}.open();

private void processScanResult(ScanIteration<T> result) {
  if (result == null) {
    resetDelegate();
    state = CursorState.FINISHED;
    return;
  }
  cursorId = Long.valueOf(result.getCursorId());
  if (isFinished(cursorId)) {
    state = CursorState.FINISHED;
  }
  if (!CollectionUtils.isEmpty(result.getItems())) {
    delegate = result.iterator();
  } else {
    resetDelegate();
  }
}

  @Override
  protected ScanIteration<Tuple> doScan(byte[] key, long cursorId, ScanOptions options) {
    if (isQueueing() || isPipelined()) {
      throw new UnsupportedOperationException("'ZSCAN' cannot be called in pipeline / transaction mode.");
    }
    List<Object> args = new ArrayList<Object>();
    args.add(key);
    args.add(cursorId);
    if (options.getPattern() != null) {
      args.add("MATCH");
      args.add(options.getPattern());
    }
    if (options.getCount() != null) {
      args.add("COUNT");
      args.add(options.getCount());
    }
    
    RFuture<ListScanResult<Tuple>> f = executorService.readAsync(client, key, ByteArrayCodec.INSTANCE, ZSCAN, args.toArray());
    ListScanResult<Tuple> res = syncFuture(f);
    client = res.getRedisClient();
    return new ScanIteration<Tuple>(res.getPos(), res.getValues());
  }
}.open();

private void processScanResult(ScanIteration<T> result) {
  if (result == null) {
    resetDelegate();
    state = CursorState.FINISHED;
    return;
  }
  cursorId = Long.valueOf(result.getCursorId());
  if (isFinished(cursorId)) {
    state = CursorState.FINISHED;
  }
  if (!CollectionUtils.isEmpty(result.getItems())) {
    delegate = result.iterator();
  } else {
    resetDelegate();
  }
}

  @Override
  protected ScanIteration<Entry<byte[], byte[]>> doScan(byte[] key, long cursorId, ScanOptions options) {
    if (isQueueing() || isPipelined()) {
      throw new UnsupportedOperationException("'HSCAN' cannot be called in pipeline / transaction mode.");
    }
    List<Object> args = new ArrayList<Object>();
    args.add(key);
    args.add(cursorId);
    if (options.getPattern() != null) {
      args.add("MATCH");
      args.add(options.getPattern());
    }
    if (options.getCount() != null) {
      args.add("COUNT");
      args.add(options.getCount());
    }
    
    RFuture<MapScanResult<byte[], byte[]>> f = executorService.readAsync(client, key, ByteArrayCodec.INSTANCE, RedisCommands.HSCAN, args.toArray());
    MapScanResult<byte[], byte[]> res = syncFuture(f);
    client = res.getRedisClient();
    return new ScanIteration<Entry<byte[], byte[]>>(res.getPos(), res.getValues());
  }
}.open();

  @Override
  protected ScanIteration<Entry<byte[], byte[]>> doScan(byte[] key, long cursorId, ScanOptions options) {
    if (isQueueing() || isPipelined()) {
      throw new UnsupportedOperationException("'HSCAN' cannot be called in pipeline / transaction mode.");
    }
    List<Object> args = new ArrayList<Object>();
    args.add(key);
    args.add(cursorId);
    if (options.getPattern() != null) {
      args.add("MATCH");
      args.add(options.getPattern());
    }
    if (options.getCount() != null) {
      args.add("COUNT");
      args.add(options.getCount());
    }
    
    RFuture<MapScanResult<byte[], byte[]>> f = executorService.readAsync(client, key, ByteArrayCodec.INSTANCE, RedisCommands.HSCAN, args.toArray());
    MapScanResult<byte[], byte[]> res = syncFuture(f);
    client = res.getRedisClient();
    return new ScanIteration<Entry<byte[], byte[]>>(res.getPos(), res.getValues());
  }
}.open();

  @Override
  protected ScanIteration<byte[]> doScan(byte[] key, long cursorId, ScanOptions options) {
    if (isQueueing() || isPipelined()) {
      throw new UnsupportedOperationException("'SSCAN' cannot be called in pipeline / transaction mode.");
    }
    List<Object> args = new ArrayList<Object>();
    args.add(key);
    args.add(cursorId);
    if (options.getPattern() != null) {
      args.add("MATCH");
      args.add(options.getPattern());
    }
    if (options.getCount() != null) {
      args.add("COUNT");
      args.add(options.getCount());
    }
    
    RFuture<ListScanResult<byte[]>> f = executorService.readAsync(client, key, ByteArrayCodec.INSTANCE, RedisCommands.SSCAN, args.toArray());
    ListScanResult<byte[]> res = syncFuture(f);
    client = res.getRedisClient();
    return new ScanIteration<byte[]>(res.getPos(), res.getValues());
  }
}.open();

  @Override
  protected ScanIteration<Entry<byte[], byte[]>> doScan(byte[] key, long cursorId, ScanOptions options) {
    if (isQueueing() || isPipelined()) {
      throw new UnsupportedOperationException("'HSCAN' cannot be called in pipeline / transaction mode.");
    }
    List<Object> args = new ArrayList<Object>();
    args.add(key);
    args.add(cursorId);
    if (options.getPattern() != null) {
      args.add("MATCH");
      args.add(options.getPattern());
    }
    if (options.getCount() != null) {
      args.add("COUNT");
      args.add(options.getCount());
    }
    
    RFuture<MapScanResult<byte[], byte[]>> f = executorService.readAsync(client, key, ByteArrayCodec.INSTANCE, RedisCommands.HSCAN, args.toArray());
    MapScanResult<byte[], byte[]> res = syncFuture(f);
    client = res.getRedisClient();
    return new ScanIteration<Entry<byte[], byte[]>>(res.getPos(), res.getValues());
  }
}.open();

  @Override
  protected ScanIteration<Entry<byte[], byte[]>> doScan(byte[] key, long cursorId, ScanOptions options) {
    if (isQueueing() || isPipelined()) {
      throw new UnsupportedOperationException("'HSCAN' cannot be called in pipeline / transaction mode.");
    }
    List<Object> args = new ArrayList<Object>();
    args.add(key);
    args.add(cursorId);
    if (options.getPattern() != null) {
      args.add("MATCH");
      args.add(options.getPattern());
    }
    if (options.getCount() != null) {
      args.add("COUNT");
      args.add(options.getCount());
    }
    
    RFuture<MapScanResult<byte[], byte[]>> f = executorService.readAsync(client, key, ByteArrayCodec.INSTANCE, RedisCommands.HSCAN, args.toArray());
    MapScanResult<byte[], byte[]> res = syncFuture(f);
    client = res.getRedisClient();
    return new ScanIteration<Entry<byte[], byte[]>>(res.getPos(), res.getValues());
  }
}.open();

  @Override
  protected ScanIteration<Tuple> doScan(byte[] key, long cursorId, ScanOptions options) {
    if (isQueueing() || isPipelined()) {
      throw new UnsupportedOperationException("'ZSCAN' cannot be called in pipeline / transaction mode.");
    }
    List<Object> args = new ArrayList<Object>();
    args.add(key);
    args.add(cursorId);
    if (options.getPattern() != null) {
      args.add("MATCH");
      args.add(options.getPattern());
    }
    if (options.getCount() != null) {
      args.add("COUNT");
      args.add(options.getCount());
    }
    
    RFuture<ListScanResult<Tuple>> f = executorService.readAsync(client, key, ByteArrayCodec.INSTANCE, ZSCAN, args.toArray());
    ListScanResult<Tuple> res = syncFuture(f);
    client = res.getRedisClient();
    return new ScanIteration<Tuple>(res.getPos(), res.getValues());
  }
}.open();

  @Override
  protected ScanIteration<Tuple> doScan(byte[] key, long cursorId, ScanOptions options) {
    if (isQueueing() || isPipelined()) {
      throw new UnsupportedOperationException("'ZSCAN' cannot be called in pipeline / transaction mode.");
    }
    List<Object> args = new ArrayList<Object>();
    args.add(key);
    args.add(cursorId);
    if (options.getPattern() != null) {
      args.add("MATCH");
      args.add(options.getPattern());
    }
    if (options.getCount() != null) {
      args.add("COUNT");
      args.add(options.getCount());
    }
    
    RFuture<ListScanResult<Tuple>> f = executorService.readAsync(client, key, ByteArrayCodec.INSTANCE, ZSCAN, args.toArray());
    ListScanResult<Tuple> res = syncFuture(f);
    client = res.getRedisClient();
    return new ScanIteration<Tuple>(res.getPos(), res.getValues());
  }
}.open();

  @Override
  protected ScanIteration<byte[]> doScan(byte[] key, long cursorId, ScanOptions options) {
    if (isQueueing() || isPipelined()) {
      throw new UnsupportedOperationException("'SSCAN' cannot be called in pipeline / transaction mode.");
    }
    List<Object> args = new ArrayList<Object>();
    args.add(key);
    args.add(cursorId);
    if (options.getPattern() != null) {
      args.add("MATCH");
      args.add(options.getPattern());
    }
    if (options.getCount() != null) {
      args.add("COUNT");
      args.add(options.getCount());
    }
    
    RFuture<ListScanResult<byte[]>> f = executorService.readAsync(client, key, ByteArrayCodec.INSTANCE, RedisCommands.SSCAN, args.toArray());
    ListScanResult<byte[]> res = syncFuture(f);
    client = res.getRedisClient();
    return new ScanIteration<byte[]>(res.getPos(), res.getValues());
  }
}.open();

  @Override
  protected ScanIteration<byte[]> doScan(byte[] key, long cursorId, ScanOptions options) {
    if (isQueueing() || isPipelined()) {
      throw new UnsupportedOperationException("'SSCAN' cannot be called in pipeline / transaction mode.");
    }
    List<Object> args = new ArrayList<Object>();
    args.add(key);
    args.add(cursorId);
    if (options.getPattern() != null) {
      args.add("MATCH");
      args.add(options.getPattern());
    }
    if (options.getCount() != null) {
      args.add("COUNT");
      args.add(options.getCount());
    }
    
    RFuture<ListScanResult<byte[]>> f = executorService.readAsync(client, key, ByteArrayCodec.INSTANCE, RedisCommands.SSCAN, args.toArray());
    ListScanResult<byte[]> res = syncFuture(f);
    client = res.getRedisClient();
    return new ScanIteration<byte[]>(res.getPos(), res.getValues());
  }
}.open();

return new ScanIteration<byte[]>(pos, res.getValues());

return new ScanIteration<byte[]>(pos, res.getValues());

return new ScanIteration<byte[]>(pos, res.getValues());

return new ScanIteration<byte[]>(pos, res.getValues());

@Override
protected ScanIteration<Entry<byte[], byte[]>> doScan(byte[] key, long cursorId, ScanOptions options) {
  if (isQueueing() || isPipelined()) {
    throw new UnsupportedOperationException("'HSCAN' cannot be called in pipeline / transaction mode.");
  }
  io.lettuce.core.ScanCursor scanCursor = connection.getScanCursor(cursorId);
  ScanArgs scanArgs = LettuceConverters.toScanArgs(options);
  MapScanCursor<byte[], byte[]> mapScanCursor = getConnection().hscan(key, scanCursor, scanArgs);
  String nextCursorId = mapScanCursor.getCursor();
  Map<byte[], byte[]> values = mapScanCursor.getMap();
  return new ScanIteration<>(Long.valueOf(nextCursorId), values.entrySet());
}

Javadoc

ScanIteration holds the values contained in Redis Multibulk reply on exectuting SCANcommand.

Most used methods

<init>
getCursorId
The cursor id to be used for subsequent requests.
getItems
Get the items returned.
iterator

Popular in Java

Reactive rest calls using spring rest template
getSystemService (Context)
findViewById (Activity)
onCreateOptionsMenu (Activity)
Socket (java.net)
Provides a client-side TCP socket.
MessageFormat (java.text)
Produces concatenated messages in language-neutral way. New code should probably use java.util.Forma
NoSuchElementException (java.util)
Thrown when trying to retrieve an element past the end of an Enumeration or Iterator.
ImageIO (javax.imageio)
BasicDataSource (org.apache.commons.dbcp)
Basic implementation of javax.sql.DataSource that is configured via JavaBeans properties. This is no
SAXParseException (org.xml.sax)
Encapsulate an XML parse error or warning.> This module, both source code and documentation, is in t
Github Copilot alternatives

How to useScanIteration in org.springframework.data.redis.core

Best Java code snippets using org.springframework.data.redis.core.ScanIteration (Showing top 20 results out of 315)

How to use
ScanIteration
in
org.springframework.data.redis.core