2021-01-30 20:16:14 +01:00
|
|
|
package it.cavallium.dbengine.database.collections;
|
|
|
|
|
2021-04-30 19:15:04 +02:00
|
|
|
import io.netty.buffer.ByteBuf;
|
2021-05-02 19:18:15 +02:00
|
|
|
import io.netty.util.ReferenceCounted;
|
2021-01-30 20:16:14 +01:00
|
|
|
import it.cavallium.dbengine.client.CompositeSnapshot;
|
|
|
|
import it.cavallium.dbengine.database.LLDictionary;
|
2021-01-31 21:23:43 +01:00
|
|
|
import it.cavallium.dbengine.database.LLDictionaryResultType;
|
|
|
|
import it.cavallium.dbengine.database.LLUtils;
|
2021-05-02 19:18:15 +02:00
|
|
|
import it.cavallium.dbengine.database.UpdateMode;
|
2021-02-02 19:40:37 +01:00
|
|
|
import it.cavallium.dbengine.database.serialization.Serializer;
|
|
|
|
import it.cavallium.dbengine.database.serialization.SerializerFixedBinaryLength;
|
2021-01-31 21:23:43 +01:00
|
|
|
import java.util.HashMap;
|
2021-01-30 20:16:14 +01:00
|
|
|
import java.util.Map;
|
|
|
|
import java.util.Map.Entry;
|
2021-05-02 19:18:15 +02:00
|
|
|
import java.util.Objects;
|
2021-02-06 19:21:31 +01:00
|
|
|
import java.util.function.Function;
|
2021-01-30 20:16:14 +01:00
|
|
|
import org.jetbrains.annotations.Nullable;
|
|
|
|
import reactor.core.publisher.Flux;
|
|
|
|
import reactor.core.publisher.Mono;
|
|
|
|
|
2021-01-31 21:23:43 +01:00
|
|
|
/**
|
|
|
|
* Optimized implementation of "DatabaseMapDictionary with SubStageGetterSingle"
|
|
|
|
*/
|
|
|
|
public class DatabaseMapDictionary<T, U> extends DatabaseMapDictionaryDeep<T, U, DatabaseStageEntry<U>> {
|
2021-01-30 20:16:14 +01:00
|
|
|
|
2021-04-30 19:15:04 +02:00
|
|
|
private final Serializer<U, ByteBuf> valueSerializer;
|
2021-01-30 20:16:14 +01:00
|
|
|
|
2021-02-01 11:00:27 +01:00
|
|
|
protected DatabaseMapDictionary(LLDictionary dictionary,
|
2021-04-30 19:15:04 +02:00
|
|
|
ByteBuf prefixKey,
|
|
|
|
SerializerFixedBinaryLength<T, ByteBuf> keySuffixSerializer,
|
|
|
|
Serializer<U, ByteBuf> valueSerializer) {
|
|
|
|
// Do not retain or release or use the prefixKey here
|
2021-02-02 19:40:37 +01:00
|
|
|
super(dictionary, prefixKey, keySuffixSerializer, new SubStageGetterSingle<>(valueSerializer), 0);
|
2021-04-30 19:15:04 +02:00
|
|
|
prefixKey = null;
|
2021-01-31 21:23:43 +01:00
|
|
|
this.valueSerializer = valueSerializer;
|
2021-01-30 20:16:14 +01:00
|
|
|
}
|
|
|
|
|
2021-01-31 21:23:43 +01:00
|
|
|
public static <T, U> DatabaseMapDictionary<T, U> simple(LLDictionary dictionary,
|
2021-04-30 19:15:04 +02:00
|
|
|
SerializerFixedBinaryLength<T, ByteBuf> keySerializer,
|
|
|
|
Serializer<U, ByteBuf> valueSerializer) {
|
2021-05-03 21:41:51 +02:00
|
|
|
return new DatabaseMapDictionary<>(dictionary, dictionary.getAllocator().buffer(0), keySerializer, valueSerializer);
|
2021-01-30 20:16:14 +01:00
|
|
|
}
|
|
|
|
|
2021-01-31 21:23:43 +01:00
|
|
|
public static <T, U> DatabaseMapDictionary<T, U> tail(LLDictionary dictionary,
|
2021-04-30 19:15:04 +02:00
|
|
|
ByteBuf prefixKey,
|
|
|
|
SerializerFixedBinaryLength<T, ByteBuf> keySuffixSerializer,
|
|
|
|
Serializer<U, ByteBuf> valueSerializer) {
|
2021-01-31 21:23:43 +01:00
|
|
|
return new DatabaseMapDictionary<>(dictionary, prefixKey, keySuffixSerializer, valueSerializer);
|
2021-01-30 20:16:14 +01:00
|
|
|
}
|
|
|
|
|
2021-04-30 19:15:04 +02:00
|
|
|
private ByteBuf toKey(ByteBuf suffixKey) {
|
|
|
|
try {
|
2021-05-02 19:18:15 +02:00
|
|
|
assert suffixKeyConsistency(suffixKey.readableBytes());
|
2021-05-03 21:41:51 +02:00
|
|
|
return LLUtils.compositeBuffer(dictionary.getAllocator(), keyPrefix.retain(), suffixKey.retain());
|
2021-04-30 19:15:04 +02:00
|
|
|
} finally {
|
|
|
|
suffixKey.release();
|
|
|
|
}
|
2021-01-30 20:16:14 +01:00
|
|
|
}
|
|
|
|
|
2021-01-31 21:23:43 +01:00
|
|
|
@Override
|
2021-03-18 16:19:41 +01:00
|
|
|
public Mono<Map<T, U>> get(@Nullable CompositeSnapshot snapshot, boolean existsAlmostCertainly) {
|
2021-01-31 21:23:43 +01:00
|
|
|
return dictionary
|
2021-04-30 19:15:04 +02:00
|
|
|
.getRange(resolveSnapshot(snapshot), range.retain(), existsAlmostCertainly)
|
2021-02-01 11:00:27 +01:00
|
|
|
.collectMap(
|
2021-05-03 18:07:18 +02:00
|
|
|
entry -> deserializeSuffix(stripPrefix(entry.getKey(), false)),
|
2021-02-01 11:00:27 +01:00
|
|
|
entry -> deserialize(entry.getValue()),
|
2021-05-02 19:18:15 +02:00
|
|
|
HashMap::new)
|
|
|
|
.filter(map -> !map.isEmpty());
|
2021-01-31 19:52:47 +01:00
|
|
|
}
|
|
|
|
|
2021-01-31 21:23:43 +01:00
|
|
|
@Override
|
|
|
|
public Mono<Map<T, U>> setAndGetPrevious(Map<T, U> value) {
|
2021-05-02 19:18:15 +02:00
|
|
|
return Mono
|
|
|
|
.usingWhen(
|
|
|
|
Mono.just(true),
|
|
|
|
b -> get(null, false),
|
|
|
|
b -> dictionary
|
|
|
|
.setRange(range.retain(),
|
|
|
|
Flux
|
|
|
|
.fromIterable(value.entrySet())
|
|
|
|
.map(entry -> Map
|
|
|
|
.entry(this.toKey(serializeSuffix(entry.getKey())), serialize(entry.getValue()))
|
|
|
|
)
|
|
|
|
)
|
|
|
|
);
|
2021-01-31 19:52:47 +01:00
|
|
|
}
|
|
|
|
|
2021-01-31 21:23:43 +01:00
|
|
|
@Override
|
|
|
|
public Mono<Map<T, U>> clearAndGetPrevious() {
|
2021-05-02 19:18:15 +02:00
|
|
|
return this
|
|
|
|
.setAndGetPrevious(Map.of());
|
2021-01-30 20:16:14 +01:00
|
|
|
}
|
|
|
|
|
2021-01-31 21:23:43 +01:00
|
|
|
@Override
|
2021-02-24 16:43:07 +01:00
|
|
|
public Mono<Long> leavesCount(@Nullable CompositeSnapshot snapshot, boolean fast) {
|
2021-04-30 19:15:04 +02:00
|
|
|
return dictionary.sizeRange(resolveSnapshot(snapshot), range.retain(), fast);
|
2021-01-30 20:16:14 +01:00
|
|
|
}
|
|
|
|
|
2021-03-14 03:13:19 +01:00
|
|
|
@Override
|
|
|
|
public Mono<Boolean> isEmpty(@Nullable CompositeSnapshot snapshot) {
|
2021-04-30 19:15:04 +02:00
|
|
|
return dictionary.isRangeEmpty(resolveSnapshot(snapshot), range.retain());
|
2021-03-14 03:13:19 +01:00
|
|
|
}
|
|
|
|
|
2021-01-31 21:23:43 +01:00
|
|
|
@Override
|
|
|
|
public Mono<DatabaseStageEntry<U>> at(@Nullable CompositeSnapshot snapshot, T keySuffix) {
|
2021-02-01 11:00:27 +01:00
|
|
|
return Mono
|
2021-05-02 19:18:15 +02:00
|
|
|
.fromSupplier(() -> new DatabaseSingle<>(dictionary, toKey(serializeSuffix(keySuffix)), Serializer.noop()))
|
|
|
|
.<DatabaseStageEntry<U>>map(entry -> new DatabaseSingleMapped<>(entry, valueSerializer));
|
2021-01-30 20:16:14 +01:00
|
|
|
}
|
|
|
|
|
2021-01-31 21:23:43 +01:00
|
|
|
@Override
|
2021-03-18 16:19:41 +01:00
|
|
|
public Mono<U> getValue(@Nullable CompositeSnapshot snapshot, T keySuffix, boolean existsAlmostCertainly) {
|
2021-05-02 19:18:15 +02:00
|
|
|
return Mono
|
|
|
|
.using(
|
|
|
|
() -> toKey(serializeSuffix(keySuffix)),
|
|
|
|
keyBuf -> dictionary
|
|
|
|
.get(resolveSnapshot(snapshot), keyBuf.retain(), existsAlmostCertainly)
|
|
|
|
.map(this::deserialize),
|
|
|
|
ReferenceCounted::release
|
|
|
|
);
|
2021-01-30 20:16:14 +01:00
|
|
|
}
|
|
|
|
|
2021-01-31 21:23:43 +01:00
|
|
|
@Override
|
|
|
|
public Mono<Void> putValue(T keySuffix, U value) {
|
2021-04-30 19:15:04 +02:00
|
|
|
ByteBuf keySuffixBuf = serializeSuffix(keySuffix);
|
|
|
|
ByteBuf keyBuf = toKey(keySuffixBuf.retain());
|
|
|
|
ByteBuf valueBuf = serialize(value);
|
2021-05-03 12:29:15 +02:00
|
|
|
return dictionary
|
|
|
|
.put(keyBuf.retain(), valueBuf.retain(), LLDictionaryResultType.VOID)
|
|
|
|
.doOnNext(ReferenceCounted::release)
|
|
|
|
.doFinally(s -> {
|
|
|
|
keyBuf.release();
|
|
|
|
keySuffixBuf.release();
|
|
|
|
valueBuf.release();
|
|
|
|
})
|
|
|
|
.then();
|
2021-01-30 20:16:14 +01:00
|
|
|
}
|
|
|
|
|
2021-05-02 19:18:15 +02:00
|
|
|
@Override
|
|
|
|
public Mono<UpdateMode> getUpdateMode() {
|
|
|
|
return dictionary.getUpdateMode();
|
|
|
|
}
|
|
|
|
|
2021-02-06 19:21:31 +01:00
|
|
|
@Override
|
2021-03-18 16:19:41 +01:00
|
|
|
public Mono<Boolean> updateValue(T keySuffix,
|
|
|
|
boolean existsAlmostCertainly,
|
2021-04-30 19:15:04 +02:00
|
|
|
Function<@Nullable U, @Nullable U> updater) {
|
2021-05-02 19:18:15 +02:00
|
|
|
return Mono
|
|
|
|
.using(
|
|
|
|
() -> toKey(serializeSuffix(keySuffix)),
|
|
|
|
keyBuf -> dictionary.update(keyBuf.retain(), oldSerialized -> {
|
|
|
|
try {
|
|
|
|
var result = updater.apply(oldSerialized == null ? null : this.deserialize(oldSerialized.retain()));
|
|
|
|
if (result == null) {
|
|
|
|
return null;
|
|
|
|
} else {
|
|
|
|
return this.serialize(result);
|
|
|
|
}
|
|
|
|
} finally {
|
|
|
|
if (oldSerialized != null) {
|
|
|
|
oldSerialized.release();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}, existsAlmostCertainly),
|
|
|
|
ReferenceCounted::release
|
|
|
|
);
|
2021-02-06 19:21:31 +01:00
|
|
|
}
|
|
|
|
|
2021-01-31 21:23:43 +01:00
|
|
|
@Override
|
|
|
|
public Mono<U> putValueAndGetPrevious(T keySuffix, U value) {
|
2021-04-30 19:15:04 +02:00
|
|
|
ByteBuf keySuffixBuf = serializeSuffix(keySuffix);
|
|
|
|
ByteBuf keyBuf = toKey(keySuffixBuf.retain());
|
|
|
|
ByteBuf valueBuf = serialize(value);
|
2021-01-31 21:23:43 +01:00
|
|
|
return dictionary
|
2021-04-30 19:15:04 +02:00
|
|
|
.put(keyBuf.retain(), valueBuf.retain(), LLDictionaryResultType.PREVIOUS_VALUE)
|
|
|
|
.map(this::deserialize)
|
|
|
|
.doFinally(s -> {
|
|
|
|
keyBuf.release();
|
|
|
|
keySuffixBuf.release();
|
|
|
|
valueBuf.release();
|
|
|
|
});
|
2021-01-31 00:36:21 +01:00
|
|
|
}
|
|
|
|
|
2021-01-31 21:23:43 +01:00
|
|
|
@Override
|
2021-05-02 19:18:15 +02:00
|
|
|
public Mono<Boolean> putValueAndGetChanged(T keySuffix, U value) {
|
2021-04-30 19:15:04 +02:00
|
|
|
ByteBuf keySuffixBuf = serializeSuffix(keySuffix);
|
|
|
|
ByteBuf keyBuf = toKey(keySuffixBuf.retain());
|
|
|
|
ByteBuf valueBuf = serialize(value);
|
2021-01-31 21:23:43 +01:00
|
|
|
return dictionary
|
2021-05-02 19:18:15 +02:00
|
|
|
.put(keyBuf.retain(), valueBuf.retain(), LLDictionaryResultType.PREVIOUS_VALUE)
|
|
|
|
.map(this::deserialize)
|
|
|
|
.map(oldValue -> !Objects.equals(oldValue, value))
|
|
|
|
.defaultIfEmpty(value != null)
|
2021-04-30 19:15:04 +02:00
|
|
|
.doFinally(s -> {
|
|
|
|
keyBuf.release();
|
|
|
|
keySuffixBuf.release();
|
|
|
|
valueBuf.release();
|
|
|
|
});
|
2021-01-31 00:36:21 +01:00
|
|
|
}
|
|
|
|
|
2021-01-31 21:23:43 +01:00
|
|
|
@Override
|
|
|
|
public Mono<Void> remove(T keySuffix) {
|
2021-05-02 19:18:15 +02:00
|
|
|
return Mono
|
|
|
|
.using(
|
|
|
|
() -> toKey(serializeSuffix(keySuffix)),
|
2021-05-03 12:29:15 +02:00
|
|
|
keyBuf -> dictionary
|
|
|
|
.remove(keyBuf.retain(), LLDictionaryResultType.VOID)
|
|
|
|
.doOnNext(ReferenceCounted::release)
|
|
|
|
.then(),
|
2021-05-02 19:18:15 +02:00
|
|
|
ReferenceCounted::release
|
|
|
|
);
|
2021-01-30 20:16:14 +01:00
|
|
|
}
|
|
|
|
|
2021-01-31 21:23:43 +01:00
|
|
|
@Override
|
|
|
|
public Mono<U> removeAndGetPrevious(T keySuffix) {
|
2021-04-30 19:15:04 +02:00
|
|
|
ByteBuf keySuffixBuf = serializeSuffix(keySuffix);
|
|
|
|
ByteBuf keyBuf = toKey(keySuffixBuf.retain());
|
2021-01-31 21:23:43 +01:00
|
|
|
return dictionary
|
2021-04-30 19:15:04 +02:00
|
|
|
.remove(keyBuf.retain(), LLDictionaryResultType.PREVIOUS_VALUE)
|
|
|
|
.map(this::deserialize)
|
|
|
|
.doFinally(s -> {
|
|
|
|
keyBuf.release();
|
|
|
|
keySuffixBuf.release();
|
|
|
|
});
|
2021-01-30 20:16:14 +01:00
|
|
|
}
|
|
|
|
|
2021-01-31 21:23:43 +01:00
|
|
|
@Override
|
|
|
|
public Mono<Boolean> removeAndGetStatus(T keySuffix) {
|
2021-04-30 19:15:04 +02:00
|
|
|
ByteBuf keySuffixBuf = serializeSuffix(keySuffix);
|
|
|
|
ByteBuf keyBuf = toKey(keySuffixBuf.retain());
|
2021-01-31 21:23:43 +01:00
|
|
|
return dictionary
|
2021-04-30 19:15:04 +02:00
|
|
|
.remove(keyBuf.retain(), LLDictionaryResultType.PREVIOUS_VALUE_EXISTENCE)
|
|
|
|
.map(LLUtils::responseToBoolean)
|
|
|
|
.doFinally(s -> {
|
|
|
|
keyBuf.release();
|
|
|
|
keySuffixBuf.release();
|
|
|
|
});
|
2021-01-30 20:16:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2021-03-18 16:19:41 +01:00
|
|
|
public Flux<Entry<T, U>> getMulti(@Nullable CompositeSnapshot snapshot, Flux<T> keys, boolean existsAlmostCertainly) {
|
2021-01-31 21:23:43 +01:00
|
|
|
return dictionary
|
2021-04-30 19:15:04 +02:00
|
|
|
.getMulti(resolveSnapshot(snapshot), keys.flatMap(keySuffix -> Mono.fromCallable(() -> {
|
|
|
|
ByteBuf keySuffixBuf = serializeSuffix(keySuffix);
|
|
|
|
try {
|
|
|
|
return toKey(keySuffixBuf.retain());
|
|
|
|
} finally {
|
|
|
|
keySuffixBuf.release();
|
|
|
|
}
|
|
|
|
})), existsAlmostCertainly)
|
2021-05-02 19:18:15 +02:00
|
|
|
.flatMap(entry -> Mono
|
2021-05-03 18:07:18 +02:00
|
|
|
.fromCallable(() -> Map.entry(deserializeSuffix(stripPrefix(entry.getKey(), false)), deserialize(entry.getValue())))
|
2021-05-02 19:18:15 +02:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
private Entry<ByteBuf, ByteBuf> serializeEntry(T key, U value) {
|
|
|
|
ByteBuf serializedKey = toKey(serializeSuffix(key));
|
|
|
|
try {
|
|
|
|
ByteBuf serializedValue = serialize(value);
|
|
|
|
try {
|
|
|
|
return Map.entry(serializedKey.retain(), serializedValue.retain());
|
|
|
|
} finally {
|
|
|
|
serializedValue.release();
|
|
|
|
}
|
|
|
|
} finally {
|
|
|
|
serializedKey.release();
|
|
|
|
}
|
2021-01-30 20:16:14 +01:00
|
|
|
}
|
|
|
|
|
2021-02-01 02:21:53 +01:00
|
|
|
@Override
|
|
|
|
public Mono<Void> putMulti(Flux<Entry<T, U>> entries) {
|
2021-05-02 19:18:15 +02:00
|
|
|
var serializedEntries = entries
|
|
|
|
.flatMap(entry -> Mono
|
|
|
|
.fromCallable(() -> serializeEntry(entry.getKey(), entry.getValue()))
|
2021-05-03 18:07:18 +02:00
|
|
|
.doOnDiscard(Entry.class, uncastedEntry -> {
|
|
|
|
//noinspection unchecked
|
|
|
|
var castedEntry = (Entry<ByteBuf, ByteBuf>) uncastedEntry;
|
|
|
|
castedEntry.getKey().release();
|
|
|
|
castedEntry.getValue().release();
|
|
|
|
})
|
|
|
|
);
|
2021-02-01 02:21:53 +01:00
|
|
|
return dictionary
|
2021-05-02 19:18:15 +02:00
|
|
|
.putMulti(serializedEntries, false)
|
2021-02-01 02:21:53 +01:00
|
|
|
.then();
|
|
|
|
}
|
|
|
|
|
2021-01-30 20:16:14 +01:00
|
|
|
@Override
|
2021-01-31 21:23:43 +01:00
|
|
|
public Flux<Entry<T, DatabaseStageEntry<U>>> getAllStages(@Nullable CompositeSnapshot snapshot) {
|
|
|
|
return dictionary
|
2021-04-30 19:15:04 +02:00
|
|
|
.getRangeKeys(resolveSnapshot(snapshot), range.retain())
|
2021-05-02 19:18:15 +02:00
|
|
|
.map(key -> {
|
2021-05-03 18:07:18 +02:00
|
|
|
ByteBuf keySuffixWithExt = stripPrefix(key, false);
|
|
|
|
// Don't use "key" under this point ---
|
2021-05-02 19:18:15 +02:00
|
|
|
try {
|
2021-05-03 18:07:18 +02:00
|
|
|
return Map.entry(deserializeSuffix(keySuffixWithExt.retainedSlice()),
|
2021-05-02 19:18:15 +02:00
|
|
|
new DatabaseSingleMapped<>(new DatabaseSingle<>(dictionary,
|
2021-05-03 18:07:18 +02:00
|
|
|
toKey(keySuffixWithExt.retainedSlice()),
|
2021-05-02 19:18:15 +02:00
|
|
|
Serializer.noop()
|
|
|
|
), valueSerializer)
|
|
|
|
);
|
|
|
|
} finally {
|
2021-05-03 18:07:18 +02:00
|
|
|
keySuffixWithExt.release();
|
2021-05-02 19:18:15 +02:00
|
|
|
}
|
|
|
|
});
|
2021-01-30 20:16:14 +01:00
|
|
|
}
|
2021-01-31 12:02:02 +01:00
|
|
|
|
2021-03-22 20:02:19 +01:00
|
|
|
@Override
|
|
|
|
public Flux<Entry<T, U>> getAllValues(@Nullable CompositeSnapshot snapshot) {
|
|
|
|
return dictionary
|
2021-04-30 19:15:04 +02:00
|
|
|
.getRange(resolveSnapshot(snapshot), range.retain())
|
2021-03-22 20:02:19 +01:00
|
|
|
.map(serializedEntry -> Map.entry(
|
2021-05-03 18:07:18 +02:00
|
|
|
deserializeSuffix(stripPrefix(serializedEntry.getKey(), false)),
|
2021-03-22 20:02:19 +01:00
|
|
|
valueSerializer.deserialize(serializedEntry.getValue())
|
2021-05-02 19:18:15 +02:00
|
|
|
))
|
|
|
|
.doOnDiscard(Entry.class, entry -> {
|
|
|
|
//noinspection unchecked
|
|
|
|
var castedEntry = (Entry<ByteBuf, ByteBuf>) entry;
|
|
|
|
castedEntry.getKey().release();
|
|
|
|
castedEntry.getValue().release();
|
|
|
|
});
|
2021-03-22 20:02:19 +01:00
|
|
|
}
|
|
|
|
|
2021-01-31 15:47:48 +01:00
|
|
|
@Override
|
|
|
|
public Flux<Entry<T, U>> setAllValuesAndGetPrevious(Flux<Entry<T, U>> entries) {
|
2021-05-02 19:18:15 +02:00
|
|
|
return Flux
|
|
|
|
.usingWhen(
|
|
|
|
Mono.just(true),
|
|
|
|
b -> getAllValues(null),
|
|
|
|
b -> dictionary
|
|
|
|
.setRange(range.retain(),
|
|
|
|
entries.map(entry ->
|
|
|
|
Map.entry(toKey(serializeSuffix(entry.getKey())), serialize(entry.getValue()))
|
|
|
|
)
|
|
|
|
)
|
|
|
|
);
|
2021-01-31 15:47:48 +01:00
|
|
|
}
|
|
|
|
|
2021-03-14 03:13:19 +01:00
|
|
|
@Override
|
|
|
|
public Mono<Void> clear() {
|
|
|
|
if (range.isAll()) {
|
|
|
|
return dictionary
|
|
|
|
.clear();
|
|
|
|
} else if (range.isSingle()) {
|
|
|
|
return dictionary
|
2021-04-30 19:15:04 +02:00
|
|
|
.remove(range.getSingle().retain(), LLDictionaryResultType.VOID)
|
2021-05-03 12:29:15 +02:00
|
|
|
.doOnNext(ReferenceCounted::release)
|
2021-03-14 03:13:19 +01:00
|
|
|
.then();
|
|
|
|
} else {
|
|
|
|
return dictionary
|
2021-05-02 19:18:15 +02:00
|
|
|
.setRange(range.retain(), Flux.empty());
|
2021-03-14 03:13:19 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-30 19:15:04 +02:00
|
|
|
/**
|
|
|
|
* This method is just a shorter version than valueSerializer::deserialize
|
|
|
|
*/
|
|
|
|
private U deserialize(ByteBuf bytes) {
|
2021-02-01 12:19:17 +01:00
|
|
|
return valueSerializer.deserialize(bytes);
|
2021-01-31 12:02:02 +01:00
|
|
|
}
|
|
|
|
|
2021-04-30 19:15:04 +02:00
|
|
|
/**
|
|
|
|
* This method is just a shorter version than valueSerializer::serialize
|
|
|
|
*/
|
|
|
|
private ByteBuf serialize(U bytes) {
|
2021-02-01 12:19:17 +01:00
|
|
|
return valueSerializer.serialize(bytes);
|
2021-01-31 12:02:02 +01:00
|
|
|
}
|
2021-01-30 20:16:14 +01:00
|
|
|
}
|