org.redisson.client.handler.State Java Examples

@Override
public List<ByteRecord> decode(List<Object> parts, State state) {
    List<List<Object>> list = (List<List<Object>>) (Object) parts;
    List<ByteRecord> result = new ArrayList<>(parts.size()/2);

    for (List<Object> entries : list) {
        List<List<Object>> streamEntries = (List<List<Object>>) entries.get(1);
        if (streamEntries.isEmpty()) {
            continue;
        }

        String name = (String) entries.get(0);
        for (List<Object> se : streamEntries) {
            ByteRecord record = StreamRecords.newRecord()
                                    .in(name.getBytes())
                                    .withId(RecordId.of(se.get(0).toString()))
                                    .ofBytes((Map<byte[], byte[]>) se.get(1));
            result.add(record);
        }
    }
    return result;
}
 

@Override
public Object decode(final ByteBuf buf, final State state) throws IOException {
  final byte[] primaryId = new byte[buf.readUnsignedByte()];
  final byte[] secondaryId = new byte[buf.readUnsignedByte()];
  final byte[] visibility;
  if (visibilityEnabled) {
    visibility = new byte[buf.readUnsignedByte()];
  } else {
    visibility = new byte[0];
  }
  final byte[] value = new byte[buf.readUnsignedShort()];
  buf.readBytes(primaryId);
  buf.readBytes(secondaryId);
  if (visibilityEnabled) {
    buf.readBytes(visibility);
  }
  buf.readBytes(value);
  return new GeoWaveMetadata(primaryId, secondaryId, visibility, value);
}
 

@Override
public StreamInfo.XInfoConsumers decode(List<Object> parts, State state) {
    List<Object> result = new ArrayList<>();
    for (List<Object> part: (List<List<Object>>) (Object)parts) {
        Map<String, Object> res = new HashMap<>();
        res.put("name", part.get(1));
        res.put("pending", part.get(3));
        res.put("idle", part.get(5));
        List<Object> list = res.entrySet().stream()
                .flatMap(e -> Stream.of(e.getKey(), e.getValue()))
                .collect(Collectors.toList());
        result.add(list);
    }

    return StreamInfo.XInfoConsumers.fromList(groupName, result);
}
 

@Override
public List<T> decode(List<Object> parts, State state) {
    for (int i = 0; i < parts.size(); i++) {
        Object object = parts.get(i);
        if (object instanceof List) {
            if (((List) object).isEmpty()) {
                parts.set(i, null);
            }
        }
    }
    return (List<T>) parts;
}
 

@Override
public Decoder<Object> getDecoder(int paramNum, State state) {
    if (paramNum == 0) {
        return StringCodec.INSTANCE.getValueDecoder();
    }
    return null;
}
 

@Override
public Object decode(ByteBuf buf, State state) throws IOException {
    if (buf.readableBytes() == 0) {
        System.out.println("null:");
        return null;
    }
    
    byte[] result = new byte[buf.readableBytes()];
    buf.readBytes(result);
    return result;
}
 

@Override
public StreamInfo.XInfoStream decode(List<Object> parts, State state) {
    Map<String, Object> res = new HashMap<>();
    res.put("length", parts.get(1));
    res.put("radix-tree-keys", parts.get(3));
    res.put("radix-tree-nodes", parts.get(5));
    res.put("groups", parts.get(7));
    res.put("last-generated-id", parts.get(9).toString());

    List<?> firstEntry = (List<?>) parts.get(11);
    if (firstEntry != null) {
        StreamMessageId firstId = StreamIdConvertor.INSTANCE.convert(firstEntry.get(0));
        Map<Object, Object> firstData = (Map<Object, Object>) firstEntry.get(1);
        res.put("first-entry", firstData);
    }

    List<?> lastEntry = (List<?>) parts.get(13);
    if (lastEntry != null) {
        StreamMessageId lastId = StreamIdConvertor.INSTANCE.convert(lastEntry.get(0));
        Map<Object, Object> lastData = (Map<Object, Object>) lastEntry.get(1);
        res.put("last-entry", lastData);
    }

    List<Object> list = res.entrySet().stream()
                            .flatMap(e -> Stream.of(e.getKey(), e.getValue()))
                            .collect(Collectors.toList());
    return StreamInfo.XInfoStream.fromList(list);
}
 

@Override
public List<T> decode(List<Object> parts, State state) {
    if (reverse) {
        Collections.reverse(parts);
    }
    return (List<T>) parts;
}
 

@Override
public Map<K, V> decode(List<Object> parts, State state) {
    Map<K, V> result = new LinkedHashMap<>(parts.size()/2);
    for (int i = 0; i < parts.size(); i++) {
        if (i % 2 != 0) {
            result.put((K) parts.get(i-1), (V) parts.get(i));
        }
    }
    return result;
}
 

@Override
public Map<Object, Object> decode(List<Object> parts, State state) {
    Map<Object, Object> result = new HashMap<Object, Object>(parts.size()/2);
    for (int i = 0; i < parts.size(); i++) {
        if (i % 2 != 0) {
            result.put(parts.get(i-1), parts.get(i));
       }
    }
    return result;
}
 

@Override
public List<ScoredEntry<T>> decode(List<Object> parts, State state) {
    List<ScoredEntry<T>> result = new ArrayList<>();
    for (int i = 0; i < parts.size(); i += 2) {
        result.add(new ScoredEntry<T>(((Number) parts.get(i+1)).doubleValue(), (T) parts.get(i)));
    }
    return result;
}
 

@Override
public Point decode(List<Object> parts, State state) {
    if (parts.isEmpty()) {
        return null;
    }

    Double longitude = (Double)parts.get(0);
    Double latitude = (Double)parts.get(1);
    return new Point(longitude, latitude);
}
 

@Override
public List<Object> decode(List<Object> parts, State state) {
    List<Object> list = parts.stream().filter(e -> e != null).collect(Collectors.toList());
    if (list.isEmpty()) {
        return null;
    }
    return parts;
}
 

@Override
public Object decode(ByteBuf buf, State state) throws IOException {
    String str = buf.toString(CharsetUtil.UTF_8);
    buf.readerIndex(buf.readableBytes());
    try {
        Thread.sleep(2500);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return str;
}
 

@Override
public Set<Tuple> decode(List<Object> parts, State state) {
    Set<Tuple> result = new LinkedHashSet<Tuple>();
    for (int i = 0; i < parts.size(); i += 2) {
        result.add(new DefaultTuple((byte[])parts.get(i), ((Number)parts.get(i+1)).doubleValue()));
    }
    return result;
}
 

@Override
public Object decode(ByteBuf buf, State state) throws IOException {
    Kryo kryo = kryoPool.obtain();
    Input input = inputPool.obtain();
    try {
        input.setInputStream(new ByteBufInputStream(buf));
        return kryo.readClassAndObject(input);
    } finally {
        kryoPool.free(kryo);
        inputPool.free(input);
    }
}
 

@Override
public Decoder<Object> getDecoder(int paramNum, State state) {
    if (paramNum % 2 != 0) {
        return DoubleCodec.INSTANCE.getValueDecoder();
    }
    return null;
}
 

@Override
public MapCacheScanResult<Object, Object> decode(List<Object> parts, State state) {
    Long pos = (Long) parts.get(0);
    Map<Object, Object> values = (Map<Object, Object>) parts.get(1);
    List<Object> idleKeys = (List<Object>) parts.get(2);
    return new MapCacheScanResult<Object, Object>(pos, values, idleKeys);
}
 

@Override
public T decode(List<Object> parts, State state) {
    if (parts.isEmpty()) {
        return null;
    }
    return (T) parts.get(index);
}
 

@Override
public Decoder<Object> getDecoder(int paramNum, State state) {
    if (paramNum % 2 != 0) {
        return DoubleCodec.INSTANCE.getValueDecoder();
    }
    return null;
}
 

@Override
public List<Tuple> decode(List<Object> parts, State state) {
    List<Tuple> result = new ArrayList<Tuple>();
    for (int i = 0; i < parts.size(); i += 2) {
        result.add(new DefaultTuple((byte[])parts.get(i), ((Number)parts.get(i+1)).doubleValue()));
    }
    return result;
}
 

@Override
public Decoder<Object> getDecoder(int paramNum, State state) {
    if (paramNum % 2 != 0) {
        return DoubleCodec.INSTANCE.getValueDecoder();
    }
    return null;
}
 

@Override
public Decoder<Object> getDecoder(int paramNum, State state) {
    if (paramNum % 2 != 0) {
        return DoubleCodec.INSTANCE.getValueDecoder();
    }
    return null;
}
 

@Override
public Properties decode(List<Object> parts, State state) {
    Properties result = new Properties();
    for (int j = 0; j < parts.size(); j+=2) {
        Object key = parts.get(j);
        Object value = parts.get(j+1);
        result.put(key, value);
    }
    return result;
}
 

@Override
public Decoder<Object> getDecoder(int paramNum, State state) {
    if (paramNum % 2 != 0) {
        return DoubleCodec.INSTANCE.getValueDecoder();
    }
    return null;
}
 

@Override
public List<Object> decode(List<Object> parts, State state) {
    List<Object> list = parts.stream().filter(e -> e != null).collect(Collectors.toList());
    if (list.isEmpty()) {
        return null;
    }
    return parts;
}
 

@Override
public Map<String, String> decode(ByteBuf buf, State state) {
    String value = buf.toString(CharsetUtil.UTF_8);
    Map<String, String> result = new HashMap<String, String>();
    for (String entry : value.split("\r\n|\n")) {
        String[] parts = entry.split(":");
        if (parts.length == 2) {
            result.put(parts[0], parts[1]);
        }
    }
    return result;
}
 

@Override
public Decoder<Object> getDecoder(int paramNum, State state) {
    if (mapDecoded) {
        return codec.getMapKeyDecoder();
    }
    
    if (pos++ % 2 == 0) {
        return codec.getMapKeyDecoder();
    }
    return codec.getMapValueDecoder();
}
 

@Override
public List<T> decode(List<Object> parts, State state) {
    for (int i = 0; i < parts.size(); i++) {
        Object object = parts.get(i);
        if (object instanceof List) {
            if (((List) object).isEmpty()) {
                parts.set(i, null);
            }
        }
    }
    return (List<T>) parts;
}
 

@Override
public Object decode(ByteBuf buf, State state) throws IOException {
    String id = (String) StringCodec.INSTANCE.getValueDecoder().decode(buf, state);
    String[] parts = id.toString().split("-");
    if (parts.length == 1) {
        return null;
    }
    return new StreamMessageId(Long.valueOf(parts[0]), Long.valueOf(parts[1]));
}