mirror of
https://github.com/OpenHFT/Chronicle-Map.git
synced 2021-09-13 01:26:12 +00:00
1003 lines
30 KiB
Java
1003 lines
30 KiB
Java
/*
|
|
* Copyright 2014 Higher Frequency Trading
|
|
*
|
|
* http://www.higherfrequencytrading.com
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package net.openhft.chronicle.map;
|
|
|
|
import net.openhft.chronicle.hash.function.SerializableFunction;
|
|
import net.openhft.chronicle.map.MapWireHandlerBuilder.Fields;
|
|
import net.openhft.chronicle.wire.Marshallable;
|
|
import net.openhft.chronicle.wire.Wire;
|
|
import org.jetbrains.annotations.NotNull;
|
|
import org.jetbrains.annotations.Nullable;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.util.*;
|
|
import java.util.function.Consumer;
|
|
import java.util.function.Predicate;
|
|
|
|
import static java.util.Collections.emptyList;
|
|
import static net.openhft.chronicle.map.MapWireHandler.EventId;
|
|
import static net.openhft.chronicle.map.MapWireHandler.EventId.*;
|
|
|
|
|
|
/**
|
|
* @author Rob Austin.
|
|
*/
|
|
class ClientWiredStatelessChronicleMap<K, V>
|
|
implements ChronicleMap<K, V>, Cloneable, ChannelFactory {
|
|
|
|
private static final Logger LOG =
|
|
LoggerFactory.getLogger(ClientWiredStatelessChronicleMap.class);
|
|
|
|
private final ClientWiredStatelessTcpConnectionHub hub;
|
|
|
|
protected Class<K> kClass;
|
|
protected Class<V> vClass;
|
|
|
|
private boolean putReturnsNull;
|
|
private boolean removeReturnsNull;
|
|
private short channelID;
|
|
|
|
public ClientWiredStatelessChronicleMap(
|
|
@NotNull final ClientWiredChronicleMapStatelessBuilder config,
|
|
@NotNull final Class kClass, @NotNull final Class vClass, short channelID) {
|
|
this.channelID = channelID;
|
|
hub = config.hub;
|
|
this.putReturnsNull = config.putReturnsNull();
|
|
this.removeReturnsNull = config.removeReturnsNull();
|
|
this.kClass = kClass;
|
|
this.vClass = vClass;
|
|
}
|
|
|
|
|
|
@SuppressWarnings("UnusedDeclaration")
|
|
void identifier(int localIdentifier) {
|
|
hub.localIdentifier = localIdentifier;
|
|
}
|
|
|
|
@Override
|
|
public void getAll(File toFile) throws IOException {
|
|
JsonSerializer.getAll(toFile, this, emptyList());
|
|
}
|
|
|
|
@Override
|
|
public void putAll(File fromFile) throws IOException {
|
|
JsonSerializer.putAll(fromFile, this, emptyList());
|
|
}
|
|
|
|
@Override
|
|
public V newValueInstance() {
|
|
return VanillaChronicleMap.newInstance(vClass, false);
|
|
}
|
|
|
|
@Override
|
|
public K newKeyInstance() {
|
|
return VanillaChronicleMap.newInstance(kClass, true);
|
|
}
|
|
|
|
@Override
|
|
public Class<K> keyClass() {
|
|
return kClass;
|
|
}
|
|
|
|
@Override
|
|
public boolean forEachEntryWhile(Predicate<? super MapKeyContext<K, V>> predicate) {
|
|
// TODO implement!
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override
|
|
public void forEachEntry(Consumer<? super MapKeyContext<K, V>> action) {
|
|
// TODO implement!
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
|
|
public String serverApplicationVersion() {
|
|
return hub.serverApplicationVersion(channelID);
|
|
}
|
|
|
|
@Override
|
|
public void close() {
|
|
// todo add ref count
|
|
}
|
|
|
|
@Override
|
|
public Class<V> valueClass() {
|
|
return vClass;
|
|
}
|
|
|
|
|
|
@NotNull
|
|
public File file() {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@SuppressWarnings("NullableProblems")
|
|
public V putIfAbsent(K key, V value) {
|
|
|
|
if (key == null || value == null)
|
|
throw new NullPointerException();
|
|
|
|
return proxyReturnObject(putIfAbsent, key, value, vClass);
|
|
}
|
|
|
|
@SuppressWarnings("NullableProblems")
|
|
public boolean remove(Object key, Object value) {
|
|
if (key == null)
|
|
throw new NullPointerException();
|
|
|
|
return value != null && proxyReturnBoolean(removeWithValue.toString(), (K) key, (V) value);
|
|
}
|
|
|
|
@SuppressWarnings("NullableProblems")
|
|
public boolean replace(K key, V oldValue, V newValue) {
|
|
if (key == null || oldValue == null || newValue == null)
|
|
throw new NullPointerException();
|
|
return proxyReturnBoolean(replaceWithOldAndNewValue.toString(), key, oldValue, newValue);
|
|
}
|
|
|
|
@SuppressWarnings("NullableProblems")
|
|
public V replace(K key, V value) {
|
|
if (key == null || value == null)
|
|
throw new NullPointerException();
|
|
return proxyReturnObject(replace, key, value, vClass);
|
|
}
|
|
|
|
public int size() {
|
|
return (int) longSize();
|
|
}
|
|
|
|
/**
|
|
* calling this method should be avoided at all cost, as the entire {@code object} is
|
|
* serialized. This equals can be used to compare map that extends ChronicleMap. So two
|
|
* Chronicle Maps that contain the same data are considered equal, even if the instances of the
|
|
* chronicle maps were of different types
|
|
*
|
|
* @param object the object that you are comparing against
|
|
* @return true if the contain the same data
|
|
*/
|
|
@Override
|
|
public boolean equals(@Nullable Object object) {
|
|
if (this == object) return true;
|
|
if (object == null || object.getClass().isAssignableFrom(Map.class))
|
|
return false;
|
|
|
|
final Map<? extends K, ? extends V> that = (Map<? extends K, ? extends V>) object;
|
|
|
|
final int size = size();
|
|
|
|
if (that.size() != size)
|
|
return false;
|
|
|
|
final Set<Map.Entry<K, V>> entries = entrySet();
|
|
return that.entrySet().equals(entries);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return proxyReturnInt(hashCode.toString());
|
|
}
|
|
|
|
@NotNull
|
|
public String toString() {
|
|
int maxNumEntries = 100;
|
|
if (size() > 100) {
|
|
return toMap(maxNumEntries).toString() + "....";
|
|
} else {
|
|
return toMap().toString();
|
|
}
|
|
}
|
|
|
|
@NotNull
|
|
public String serverPersistedDataVersion() {
|
|
return hub.proxyReturnString(persistedDataVersion, channelID);
|
|
}
|
|
|
|
public boolean isEmpty() {
|
|
return proxyReturnBoolean(isEmpty.toString());
|
|
}
|
|
|
|
public boolean containsKey(Object key) {
|
|
return proxyReturnBooleanK(containsKey, (K) key);
|
|
}
|
|
|
|
@NotNull
|
|
private NullPointerException keyNotNullNPE() {
|
|
return new NullPointerException("key can not be null");
|
|
}
|
|
|
|
public boolean containsValue(Object value) {
|
|
return proxyReturnBooleanV(containsValue, (V) value);
|
|
}
|
|
|
|
public long longSize() {
|
|
return proxyReturnLong(longSize.toString());
|
|
}
|
|
|
|
@Override
|
|
public MapKeyContext<K, V> context(K key) {
|
|
throw new UnsupportedOperationException("Contexts are not supported by stateless clients");
|
|
}
|
|
|
|
public V get(Object key) {
|
|
return proxyReturnObject(vClass, get, (K) key);
|
|
}
|
|
|
|
@Nullable
|
|
public V getUsing(K key, V usingValue) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@NotNull
|
|
public V acquireUsing(@NotNull K key, V usingValue) {
|
|
throw new UnsupportedOperationException(
|
|
"acquireUsing() is not supported for stateless clients");
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public MapKeyContext<K, V> acquireContext(@NotNull K key, @NotNull V usingValue) {
|
|
throw new UnsupportedOperationException("Contexts are not supported by stateless clients");
|
|
}
|
|
|
|
public V remove(Object key) {
|
|
if (key == null)
|
|
throw keyNotNullNPE();
|
|
return proxyReturnObject(vClass, removeReturnsNull ? removeWithoutAcc : remove, (K) key);
|
|
}
|
|
|
|
@Override
|
|
public void createChannel(short channelID) {
|
|
proxyReturnVoid(
|
|
() -> {
|
|
hub.outWire().write(Fields.methodName).text(createChannel.toString());
|
|
hub.outWire().write(Fields.arg1).int16(channelID);
|
|
});
|
|
}
|
|
|
|
public void putAll(@NotNull Map<? extends K, ? extends V> map) {
|
|
|
|
final long startTime = System.currentTimeMillis();
|
|
long transactionId = hub.nextUniqueTransaction(startTime);
|
|
|
|
Set<? extends Map.Entry<? extends K, ? extends V>> entries = map.entrySet();
|
|
Iterator<? extends Map.Entry<? extends K, ? extends V>> iterator = entries.iterator();
|
|
|
|
OUTER:
|
|
while (iterator.hasNext()) {
|
|
hub.outBytesLock().lock();
|
|
try {
|
|
|
|
assert hub.outBytesLock().isHeldByCurrentThread();
|
|
assert !hub.inBytesLock().isHeldByCurrentThread();
|
|
|
|
Wire wire = hub.outWire();
|
|
|
|
assert hub.outBytesLock().isHeldByCurrentThread();
|
|
hub.markSize(wire);
|
|
hub.startTime(startTime);
|
|
wire.write(Fields.type).text("MAP");
|
|
wire.write(Fields.transactionId).int64(transactionId);
|
|
wire.write(Fields.timeStamp).int64(startTime);
|
|
wire.write(Fields.channelId).int16(channelID);
|
|
hub.outWire().write(Fields.methodName).text(putAll.toString());
|
|
|
|
while (iterator.hasNext()) {
|
|
|
|
Map.Entry<? extends K, ? extends V> e = iterator.next();
|
|
|
|
|
|
hub.outWire().write(Fields.hasNext).bool(iterator.hasNext());
|
|
writeField(Fields.arg1, e.getKey());
|
|
writeField(Fields.arg2, e.getValue());
|
|
|
|
if (wire.bytes().remaining() < wire.bytes().capacity() * 0.5)
|
|
break OUTER;
|
|
}
|
|
|
|
} finally {
|
|
hub.writeSocket(hub.outWire());
|
|
hub.outBytesLock().unlock();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// wait for the transaction id to be received, this will only be received once the
|
|
// last chunk has been processed
|
|
readVoid(transactionId, startTime);
|
|
}
|
|
|
|
|
|
public V put(K key, V value) {
|
|
if (key == null || value == null)
|
|
throw new NullPointerException();
|
|
return proxyReturnObject(putReturnsNull ? putWithoutAcc : put, key, value, vClass);
|
|
}
|
|
|
|
@Nullable
|
|
public <R> R getMapped(@Nullable K key, @NotNull SerializableFunction<? super V, R> function) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Nullable
|
|
@Override
|
|
public V putMapped(@Nullable K key, @NotNull UnaryOperator<V> unaryOperator) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void clear() {
|
|
proxyReturnVoid(() -> writeField(Fields.methodName, clear.toString()));
|
|
}
|
|
|
|
|
|
@NotNull
|
|
public Set<K> keySet() {
|
|
final Set<K> usingCollection = new HashSet<K>();
|
|
readChunked(kClass, keySet, usingCollection);
|
|
return usingCollection;
|
|
}
|
|
|
|
|
|
@NotNull
|
|
public Collection<V> values() {
|
|
final List<V> usingCollection = new ArrayList<>();
|
|
return readChunked(vClass, values, usingCollection);
|
|
}
|
|
|
|
private <E, A extends Collection<E>> Collection<E> readChunked(
|
|
Class<E> vClass1, EventId values, A usingCollection) {
|
|
final long startTime = System.currentTimeMillis();
|
|
|
|
// send
|
|
final long transactionId = proxySend(values, startTime);
|
|
assert !hub.outBytesLock().isHeldByCurrentThread();
|
|
final long timeoutTime = startTime + hub.timeoutMs;
|
|
|
|
OUTER:
|
|
for (; ; ) {
|
|
|
|
// receive
|
|
hub.inBytesLock().lock();
|
|
try {
|
|
final Wire wireIn = hub.proxyReply(timeoutTime, transactionId);
|
|
|
|
while (wireIn.bytes().remaining() > 0) {
|
|
boolean bool = wireIn.read(Fields.hasNext).bool();
|
|
if (bool) {
|
|
usingCollection.add(readObject(Fields.result, wireIn, null, vClass1));
|
|
} else
|
|
break OUTER;
|
|
|
|
// todo process the exception
|
|
boolean isException = wireIn.read(Fields.isException).bool();
|
|
}
|
|
|
|
} finally {
|
|
hub.inBytesLock().unlock();
|
|
}
|
|
}
|
|
return usingCollection;
|
|
}
|
|
|
|
@NotNull
|
|
public Set<Map.Entry<K, V>> entrySet() {
|
|
return toMap().entrySet();
|
|
}
|
|
|
|
private Map<K, V> toMap() {
|
|
final Map<K, V> result = new HashMap<K, V>();
|
|
final long startTime = System.currentTimeMillis();
|
|
// send
|
|
final long transactionId = proxySend(entrySet, startTime);
|
|
assert !hub.outBytesLock().isHeldByCurrentThread();
|
|
final long timeoutTime = startTime + hub.timeoutMs;
|
|
|
|
OUTER:
|
|
for (; ; ) {
|
|
|
|
// receive
|
|
hub.inBytesLock().lock();
|
|
try {
|
|
final Wire wireIn = hub.proxyReply(timeoutTime, transactionId);
|
|
|
|
while (wireIn.bytes().remaining() > 0) {
|
|
boolean bool = wireIn.read(Fields.hasNext).bool();
|
|
if (bool) {
|
|
result.put(
|
|
readK(Fields.resultKey, wireIn, null),
|
|
readV(Fields.resultValue, wireIn, null));
|
|
} else
|
|
break OUTER;
|
|
|
|
|
|
if (wireIn.bytes().remaining() > 0) {
|
|
// todo process the exception
|
|
boolean isException = wireIn.read(Fields.isException).bool();
|
|
}
|
|
}
|
|
|
|
} finally {
|
|
hub.inBytesLock().unlock();
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* returns a chunk of entries
|
|
*
|
|
* @return
|
|
* @param maxNumEntries
|
|
*/
|
|
private Map<K, V> toMap(int maxNumEntries) {
|
|
final Map<K, V> result = new HashMap<K, V>();
|
|
final long startTime = System.currentTimeMillis();
|
|
|
|
// send
|
|
final long transactionId = proxySend(entrySetRestricted, maxNumEntries, startTime);
|
|
assert !hub.outBytesLock().isHeldByCurrentThread();
|
|
final long timeoutTime = startTime + hub.timeoutMs;
|
|
|
|
OUTER:
|
|
for (; ; ) {
|
|
|
|
// receive
|
|
hub.inBytesLock().lock();
|
|
try {
|
|
final Wire wireIn = hub.proxyReply(timeoutTime, transactionId);
|
|
|
|
while (wireIn.bytes().remaining() > 0) {
|
|
boolean bool = wireIn.read(Fields.hasNext).bool();
|
|
if (bool) {
|
|
result.put(
|
|
readK(Fields.resultKey, wireIn, null),
|
|
readV(Fields.resultValue, wireIn, null));
|
|
} else
|
|
break OUTER;
|
|
|
|
|
|
if (wireIn.bytes().remaining() > 0) {
|
|
// todo process the exception
|
|
boolean isException = wireIn.read(Fields.isException).bool();
|
|
}
|
|
}
|
|
|
|
} finally {
|
|
hub.inBytesLock().unlock();
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @param callback each entry is passed to the callback
|
|
*/
|
|
void entrySet(@NotNull MapEntryCallback<K, V> callback) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
|
|
private long readLong(long transactionId, long startTime) {
|
|
assert !hub.outBytesLock().isHeldByCurrentThread();
|
|
final long timeoutTime = startTime + hub.timeoutMs;
|
|
|
|
// receive
|
|
hub.inBytesLock().lock();
|
|
try {
|
|
return hub.proxyReply(timeoutTime, transactionId).read(Fields.result).int64();
|
|
} finally {
|
|
hub.inBytesLock().unlock();
|
|
}
|
|
}
|
|
|
|
|
|
private void writeField(Fields fieldName, Object value) {
|
|
writeField(fieldName, value, hub.outWire());
|
|
}
|
|
|
|
|
|
private void writeField(Fields fieldName, Object value, Wire wire) {
|
|
|
|
assert hub.outBytesLock().isHeldByCurrentThread();
|
|
assert !hub.inBytesLock().isHeldByCurrentThread();
|
|
|
|
if (value instanceof Byte)
|
|
wire.write(fieldName).int8((Byte) value);
|
|
else if (value instanceof Character)
|
|
wire.write(fieldName).text(value.toString());
|
|
else if (value instanceof Short)
|
|
wire.write(fieldName).int16((Short) value);
|
|
else if (value instanceof Integer)
|
|
wire.write(fieldName).int32((Integer) value);
|
|
else if (value instanceof Long)
|
|
wire.write(fieldName).int64((Long) value);
|
|
else if (value instanceof CharSequence) {
|
|
wire.write(fieldName).text((CharSequence) value);
|
|
} else if (value instanceof Marshallable) {
|
|
wire.write(fieldName).marshallable((Marshallable) value);
|
|
} else {
|
|
throw new IllegalStateException("type=" + value.getClass() +
|
|
" is unsupported, it must either be of type Marshallable or CharSequence");
|
|
}
|
|
}
|
|
|
|
|
|
private V readValue(Fields argName, long transactionId, long startTime, final V usingValue) {
|
|
assert !hub.outBytesLock().isHeldByCurrentThread();
|
|
long timeoutTime = startTime + hub.timeoutMs;
|
|
|
|
hub.inBytesLock().lock();
|
|
try {
|
|
|
|
final Wire wireIn = hub.proxyReply(timeoutTime, transactionId);
|
|
|
|
if (wireIn.read(Fields.resultIsNull).bool())
|
|
return null;
|
|
|
|
return readV(argName, wireIn, usingValue);
|
|
|
|
} finally {
|
|
hub.inBytesLock().unlock();
|
|
}
|
|
}
|
|
|
|
private V readV(Fields argName, Wire wireIn, V usingValue) {
|
|
return readObject(argName, wireIn, usingValue, vClass);
|
|
}
|
|
|
|
private K readK(Fields argName, Wire wireIn, K usingValue) {
|
|
return readObject(argName, wireIn, usingValue, kClass);
|
|
}
|
|
|
|
private <E> E readObject(Fields argName, Wire wireIn, E usingValue, Class<E> clazz) {
|
|
if (StringBuilder.class.isAssignableFrom(clazz)) {
|
|
wireIn.read(argName).text((StringBuilder) usingValue);
|
|
return usingValue;
|
|
} else if (Marshallable.class.isAssignableFrom(clazz)) {
|
|
|
|
if (usingValue == null)
|
|
try {
|
|
E v = clazz.newInstance();
|
|
wireIn.read(argName).marshallable((Marshallable) v);
|
|
return v;
|
|
} catch (Exception e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
|
|
wireIn.read(argName).marshallable((Marshallable) usingValue);
|
|
return usingValue;
|
|
|
|
} else if (String.class.isAssignableFrom(clazz)) {
|
|
//noinspection unchecked
|
|
return (E) wireIn.read(argName).text();
|
|
|
|
} else if (Long.class.isAssignableFrom(clazz)) {
|
|
//noinspection unchecked
|
|
return (E) (Long) wireIn.read(argName).int64();
|
|
} else if (Double.class.isAssignableFrom(clazz)) {
|
|
//noinspection unchecked
|
|
return (E) (Double) wireIn.read(argName).float64();
|
|
|
|
} else if (Integer.class.isAssignableFrom(clazz)) {
|
|
//noinspection unchecked
|
|
return (E) (Integer) wireIn.read(argName).int32();
|
|
|
|
} else if (Float.class.isAssignableFrom(clazz)) {
|
|
//noinspection unchecked
|
|
return (E) (Float) wireIn.read(argName).float32();
|
|
|
|
} else if (Short.class.isAssignableFrom(clazz)) {
|
|
//noinspection unchecked
|
|
return (E) (Short) wireIn.read(argName).int16();
|
|
|
|
} else if (Character.class.isAssignableFrom(clazz)) {
|
|
//noinspection unchecked
|
|
final String text = wireIn.read(argName).text();
|
|
if (text == null || text.length() == 0)
|
|
return null;
|
|
return (E) (Character) text.charAt(0);
|
|
|
|
} else if (Byte.class.isAssignableFrom(clazz)) {
|
|
//noinspection unchecked
|
|
return (E) (Byte) wireIn.read(argName).int8();
|
|
|
|
|
|
} else {
|
|
throw new IllegalStateException("unsupported type");
|
|
}
|
|
}
|
|
|
|
|
|
private boolean readBoolean(long transactionId, long startTime) {
|
|
assert !hub.outBytesLock().isHeldByCurrentThread();
|
|
|
|
long timeoutTime = startTime + hub.timeoutMs;
|
|
|
|
// receive
|
|
hub.inBytesLock().lock();
|
|
try {
|
|
final Wire wireIn = hub.proxyReply(timeoutTime, transactionId);
|
|
return wireIn.read(Fields.result).bool();
|
|
} finally {
|
|
hub.inBytesLock().unlock();
|
|
}
|
|
}
|
|
|
|
private int readInt(long transactionId, long startTime) {
|
|
assert !hub.outBytesLock().isHeldByCurrentThread();
|
|
|
|
long timeoutTime = startTime + hub.timeoutMs;
|
|
|
|
// receive
|
|
hub.inBytesLock().lock();
|
|
try {
|
|
final Wire wireIn = hub.proxyReply(timeoutTime, transactionId);
|
|
return wireIn.read(Fields.result).int32();
|
|
} finally {
|
|
hub.inBytesLock().unlock();
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("SameParameterValue")
|
|
private boolean proxyReturnBoolean(@NotNull final String methodName, K key, V value) {
|
|
final long startTime = System.currentTimeMillis();
|
|
|
|
long transactionId;
|
|
|
|
hub.outBytesLock().lock();
|
|
try {
|
|
transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
|
|
hub.outWire().write(Fields.methodName).text(methodName.toString());
|
|
writeField(Fields.arg1, key);
|
|
writeField(Fields.arg2, value);
|
|
|
|
hub.writeSocket(hub.outWire());
|
|
} finally {
|
|
hub.outBytesLock().unlock();
|
|
}
|
|
|
|
return readBoolean(transactionId, startTime);
|
|
|
|
}
|
|
|
|
@SuppressWarnings("SameParameterValue")
|
|
private boolean proxyReturnBoolean(
|
|
@NotNull final String methodName, K key, V value1, V value2) {
|
|
final long startTime = System.currentTimeMillis();
|
|
|
|
long transactionId;
|
|
hub.outBytesLock().lock();
|
|
try {
|
|
transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
|
|
hub.outWire().write(Fields.methodName).text(methodName.toString());
|
|
writeField(Fields.arg1, key);
|
|
writeField(Fields.arg2, value1);
|
|
writeField(Fields.arg3, value2);
|
|
hub.writeSocket(hub.outWire());
|
|
} finally {
|
|
hub.outBytesLock().unlock();
|
|
}
|
|
|
|
return readBoolean(transactionId, startTime);
|
|
|
|
}
|
|
|
|
@SuppressWarnings("SameParameterValue")
|
|
private boolean proxyReturnBooleanV(@NotNull final EventId methodName, V value) {
|
|
final long startTime = System.currentTimeMillis();
|
|
return readBoolean(proxySend(methodName, startTime, value), startTime);
|
|
}
|
|
|
|
@SuppressWarnings("SameParameterValue")
|
|
private boolean proxyReturnBooleanK(@NotNull final EventId methodName, K key) {
|
|
final long startTime = System.currentTimeMillis();
|
|
|
|
return readBoolean(proxySend(methodName, startTime, key), startTime);
|
|
}
|
|
|
|
@SuppressWarnings("SameParameterValue")
|
|
private long proxyReturnLong(@NotNull final String methodName) {
|
|
final long startTime = System.currentTimeMillis();
|
|
|
|
long transactionId;
|
|
|
|
hub.outBytesLock().lock();
|
|
try {
|
|
transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
|
|
hub.outWire().write(Fields.methodName).text(methodName.toString());
|
|
hub.writeSocket(hub.outWire());
|
|
} finally {
|
|
hub.outBytesLock().unlock();
|
|
}
|
|
|
|
return readLong(transactionId, startTime);
|
|
}
|
|
|
|
@SuppressWarnings("SameParameterValue")
|
|
private boolean proxyReturnBoolean(@NotNull final String methodName) {
|
|
final long startTime = System.currentTimeMillis();
|
|
|
|
long transactionId;
|
|
|
|
hub.outBytesLock().lock();
|
|
try {
|
|
transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
|
|
hub.outWire().write(Fields.methodName).text(methodName.toString());
|
|
hub.writeSocket(hub.outWire());
|
|
} finally {
|
|
hub.outBytesLock().unlock();
|
|
}
|
|
|
|
return readBoolean(transactionId, startTime);
|
|
}
|
|
|
|
@SuppressWarnings("SameParameterValue")
|
|
private void proxyReturnVoid(Runnable r) {
|
|
|
|
|
|
final long startTime = System.currentTimeMillis();
|
|
long transactionId;
|
|
|
|
hub.outBytesLock().lock();
|
|
try {
|
|
transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
|
|
r.run();
|
|
hub.writeSocket(hub.outWire());
|
|
} finally {
|
|
hub.outBytesLock().unlock();
|
|
}
|
|
|
|
readVoid(transactionId, startTime);
|
|
}
|
|
|
|
|
|
@SuppressWarnings("SameParameterValue")
|
|
private int proxyReturnInt(@NotNull final String methodName) {
|
|
final long startTime = System.currentTimeMillis();
|
|
|
|
long transactionId;
|
|
|
|
hub.outBytesLock().lock();
|
|
try {
|
|
transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
|
|
hub.outWire().write(Fields.methodName).text(methodName.toString());
|
|
hub.writeSocket(hub.outWire());
|
|
} finally {
|
|
hub.outBytesLock().unlock();
|
|
}
|
|
|
|
return readInt(transactionId, startTime);
|
|
}
|
|
|
|
|
|
@Nullable
|
|
private <R> R proxyReturnObject(
|
|
@NotNull final EventId methodName, K key, V value, Class<V> resultType) {
|
|
|
|
final long startTime = System.currentTimeMillis();
|
|
long transactionId;
|
|
|
|
hub.outBytesLock().lock();
|
|
try {
|
|
assert hub.outBytesLock().isHeldByCurrentThread();
|
|
assert !hub.inBytesLock().isHeldByCurrentThread();
|
|
|
|
transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
|
|
hub.outWire().write(Fields.methodName).text(methodName.toString());
|
|
writeField(Fields.arg1, key);
|
|
writeField(Fields.arg2, value);
|
|
hub.writeSocket(hub.outWire());
|
|
|
|
} finally {
|
|
hub.outBytesLock().unlock();
|
|
}
|
|
|
|
if (eventReturnsNull(methodName))
|
|
return null;
|
|
|
|
if (resultType == vClass)
|
|
return (R) readValue(Fields.result, transactionId, startTime, null);
|
|
|
|
else
|
|
throw new UnsupportedOperationException("class of type class=" + resultType +
|
|
" is not supported");
|
|
}
|
|
|
|
@Nullable
|
|
private <R> R proxyReturnObject(
|
|
Class<R> rClass, @NotNull final EventId methodName, Object key) {
|
|
final long startTime = System.currentTimeMillis();
|
|
|
|
long transactionId;
|
|
|
|
transactionId = proxySend(methodName, startTime, key);
|
|
|
|
if (eventReturnsNull(methodName))
|
|
return null;
|
|
|
|
if (rClass == vClass)
|
|
return (R) readValue(Fields.result, transactionId, startTime, null);
|
|
else
|
|
throw new UnsupportedOperationException("class of type class=" + rClass + " is not " +
|
|
"supported");
|
|
}
|
|
|
|
private long proxySend(EventId methodName, long startTime, Object arg1) {
|
|
long transactionId;
|
|
hub.outBytesLock().lock();
|
|
try {
|
|
transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
|
|
hub.outWire().write(Fields.methodName).text(methodName.toString());
|
|
writeField(Fields.arg1, arg1);
|
|
hub.writeSocket(hub.outWire());
|
|
} finally {
|
|
hub.outBytesLock().unlock();
|
|
}
|
|
return transactionId;
|
|
}
|
|
|
|
|
|
private long proxySend(EventId methodName, long startTime) {
|
|
long transactionId;
|
|
hub.outBytesLock().lock();
|
|
try {
|
|
transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
|
|
hub.outWire().write(Fields.methodName).text(methodName.toString());
|
|
hub.writeSocket(hub.outWire());
|
|
} finally {
|
|
hub.outBytesLock().unlock();
|
|
}
|
|
return transactionId;
|
|
}
|
|
|
|
private long proxySend(EventId methodName, long arg1, long startTime) {
|
|
long transactionId;
|
|
hub.outBytesLock().lock();
|
|
try {
|
|
transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
|
|
hub.outWire().write(Fields.methodName).text(methodName.toString());
|
|
hub.outWire().write(Fields.arg1).int64(arg1);
|
|
hub.writeSocket(hub.outWire());
|
|
} finally {
|
|
hub.outBytesLock().unlock();
|
|
}
|
|
return transactionId;
|
|
}
|
|
|
|
|
|
private boolean eventReturnsNull(@NotNull EventId methodName) {
|
|
|
|
switch (methodName) {
|
|
case putAllWithoutAcc:
|
|
case putWithoutAcc:
|
|
case removeWithoutAcc:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
private void readVoid(long transactionId, long startTime) {
|
|
long timeoutTime = startTime + hub.timeoutMs;
|
|
|
|
// receive
|
|
hub.inBytesLock().lock();
|
|
try {
|
|
hub.proxyReply(timeoutTime, transactionId);
|
|
} finally {
|
|
hub.inBytesLock().unlock();
|
|
}
|
|
}
|
|
|
|
|
|
/* static enum EventId {
|
|
createChannel,
|
|
HEARTBEAT,
|
|
STATEFUL_UPDATE,
|
|
longSize,
|
|
size,
|
|
isEmpty,
|
|
containsKey,
|
|
containsValue,
|
|
get,
|
|
put,
|
|
putWithoutAcc,
|
|
remove,
|
|
removeWithoutAcc,
|
|
clear,
|
|
KEY_SET,
|
|
VALUES,
|
|
entrySet,
|
|
replace,
|
|
replaceWithOldAndNewValue,
|
|
putIfAbsent,
|
|
removeWithValue,
|
|
toString,
|
|
applicationVersion,
|
|
persistedDataVersion,
|
|
putAll,
|
|
putAllWithoutAcc,
|
|
hashCode,
|
|
mapForKey,
|
|
putMapped,
|
|
keyBuilder,
|
|
valueBuilder
|
|
}*/
|
|
|
|
class Entry implements Map.Entry<K, V> {
|
|
|
|
final K key;
|
|
final V value;
|
|
|
|
/**
|
|
* Creates new entry.
|
|
*/
|
|
Entry(K k1, V v) {
|
|
value = v;
|
|
key = k1;
|
|
}
|
|
|
|
public final K getKey() {
|
|
return key;
|
|
}
|
|
|
|
public final V getValue() {
|
|
return value;
|
|
}
|
|
|
|
public final V setValue(V newValue) {
|
|
V oldValue = value;
|
|
ClientWiredStatelessChronicleMap.this.put(getKey(), newValue);
|
|
return oldValue;
|
|
}
|
|
|
|
public final boolean equals(Object o) {
|
|
if (!(o instanceof Map.Entry))
|
|
return false;
|
|
final Map.Entry e = (Map.Entry) o;
|
|
final Object k1 = getKey();
|
|
final Object k2 = e.getKey();
|
|
if (k1 == k2 || (k1 != null && k1.equals(k2))) {
|
|
Object v1 = getValue();
|
|
Object v2 = e.getValue();
|
|
if (v1 == v2 || (v1 != null && v1.equals(v2)))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public final int hashCode() {
|
|
return (key == null ? 0 : key.hashCode()) ^
|
|
(value == null ? 0 : value.hashCode());
|
|
}
|
|
|
|
@NotNull
|
|
public final String toString() {
|
|
return getKey() + "=" + getValue();
|
|
}
|
|
}
|
|
}
|
|
|