diff --git a/platform/script-debugger/backend/src/org/jetbrains/debugger/ValueModifier.java b/platform/script-debugger/backend/src/org/jetbrains/debugger/ValueModifier.java index 4800f8005f8b..7b404382bc99 100644 --- a/platform/script-debugger/backend/src/org/jetbrains/debugger/ValueModifier.java +++ b/platform/script-debugger/backend/src/org/jetbrains/debugger/ValueModifier.java @@ -1,19 +1,17 @@ -package org.jetbrains.debugger; +package org.jetbrains.debugger -import org.jetbrains.annotations.NotNull; -import org.jetbrains.concurrency.Promise; -import org.jetbrains.debugger.values.Value; +import org.jetbrains.concurrency.Promise +import org.jetbrains.debugger.values.Value -public interface ValueModifier { +interface ValueModifier { // expression can contains reference to another variables in current scope, so, we should evaluate it before set // https://youtrack.jetbrains.com/issue/WEB-2342#comment=27-512122 // we don't worry about performance in case of simple primitive values - boolean/string/numbers, // it works quickly and we don't want to complicate our code and debugger SDK - Promise setValue(@NotNull Variable variable, String newValue, @NotNull EvaluateContext evaluateContext); + fun setValue(variable: Variable, newValue: String, evaluateContext: EvaluateContext): Promise<*> - Promise setValue(@NotNull Variable variable, @NotNull Value newValue, @NotNull EvaluateContext evaluateContext); + fun setValue(variable: Variable, newValue: Value, evaluateContext: EvaluateContext): Promise<*> - @NotNull - Promise evaluateGet(@NotNull Variable variable, @NotNull EvaluateContext evaluateContext); + fun evaluateGet(variable: Variable, evaluateContext: EvaluateContext): Promise } \ No newline at end of file diff --git a/platform/script-debugger/backend/src/org/jetbrains/debugger/values/ArrayValue.java b/platform/script-debugger/backend/src/org/jetbrains/debugger/values/ArrayValue.java index a0a8b22ccb5b..f9bd69031e27 100644 --- a/platform/script-debugger/backend/src/org/jetbrains/debugger/values/ArrayValue.java +++ b/platform/script-debugger/backend/src/org/jetbrains/debugger/values/ArrayValue.java @@ -1,14 +1,13 @@ -package org.jetbrains.debugger.values; +package org.jetbrains.debugger.values -public interface ArrayValue extends ObjectValue { +interface ArrayValue : ObjectValue { /** * Be aware - it is not equals to java array length. - * In case of sparse array {@code - * var sparseArray = [3, 4]; + * In case of sparse array `var sparseArray = [3, 4]; * sparseArray[45] = 34; - * sparseArray[40999995] = "foo"; - * } + * sparseArray[40999995] = "foo"; + ` * * length will be equal to 40999995. */ - int getLength(); + val length: Int } \ No newline at end of file diff --git a/platform/script-debugger/backend/src/org/jetbrains/debugger/values/ObjectValue.java b/platform/script-debugger/backend/src/org/jetbrains/debugger/values/ObjectValue.java index 3d9bd035ed15..ed57378999c2 100755 --- a/platform/script-debugger/backend/src/org/jetbrains/debugger/values/ObjectValue.java +++ b/platform/script-debugger/backend/src/org/jetbrains/debugger/values/ObjectValue.java @@ -1,49 +1,39 @@ -package org.jetbrains.debugger.values; +package org.jetbrains.debugger.values -import com.intellij.util.ThreeState; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.concurrency.Obsolescent; -import org.jetbrains.concurrency.Promise; -import org.jetbrains.debugger.EvaluateContext; -import org.jetbrains.debugger.Variable; -import org.jetbrains.debugger.VariablesHost; - -import java.util.List; +import com.intellij.util.ThreeState +import org.jetbrains.concurrency.Obsolescent +import org.jetbrains.concurrency.Promise +import org.jetbrains.debugger.EvaluateContext +import org.jetbrains.debugger.Variable +import org.jetbrains.debugger.VariablesHost +import org.jetbrains.debugger.Vm /** * A compound value that has zero or more properties */ -public interface ObjectValue extends Value { - @Nullable - String getClassName(); +interface ObjectValue : Value { + val className: String? - @NotNull - Promise> getProperties(); + val properties: Promise> - @NotNull - Promise> getProperties(@NotNull List names, @NotNull EvaluateContext evaluateContext, @NotNull Obsolescent obsolescent); + fun getProperties(names: List, evaluateContext: EvaluateContext, obsolescent: Obsolescent): Promise> - @NotNull - VariablesHost getVariablesHost(); + val variablesHost: VariablesHost> /** * from (inclusive) to (exclusive) ranges of array elements or elements if less than bucketThreshold - * + * "to" could be -1 (sometimes length is unknown, so, you can pass -1 instead of actual elements size) */ - @NotNull - Promise getIndexedProperties(int from, int to, int bucketThreshold, @NotNull IndexedVariablesConsumer consumer, @Nullable ValueType componentType); + fun getIndexedProperties(from: Int, to: Int, bucketThreshold: Int, consumer: IndexedVariablesConsumer, componentType: ValueType?): Promise<*> /** - * It must return quickly. Return {@link com.intellij.util.ThreeState#UNSURE} otherwise. + * It must return quickly. Return [com.intellij.util.ThreeState.UNSURE] otherwise. */ - @NotNull - ThreeState hasProperties(); + fun hasProperties() = ThreeState.UNSURE /** - * It must return quickly. Return {@link com.intellij.util.ThreeState#UNSURE} otherwise. + * It must return quickly. Return [com.intellij.util.ThreeState.UNSURE] otherwise. */ - @NotNull - ThreeState hasIndexedProperties(); + fun hasIndexedProperties() = ThreeState.NO } \ No newline at end of file diff --git a/platform/script-debugger/backend/src/org/jetbrains/debugger/values/ObjectValueBase.java b/platform/script-debugger/backend/src/org/jetbrains/debugger/values/ObjectValueBase.java index 67f375b00ad1..f6db099fc20f 100644 --- a/platform/script-debugger/backend/src/org/jetbrains/debugger/values/ObjectValueBase.java +++ b/platform/script-debugger/backend/src/org/jetbrains/debugger/values/ObjectValueBase.java @@ -1,127 +1,73 @@ -package org.jetbrains.debugger.values; +package org.jetbrains.debugger.values -import com.intellij.util.SmartList; -import com.intellij.util.ThreeState; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.concurrency.Obsolescent; -import org.jetbrains.concurrency.ObsolescentAsyncFunction; -import org.jetbrains.concurrency.Promise; -import org.jetbrains.debugger.EvaluateContext; -import org.jetbrains.debugger.ValueModifier; -import org.jetbrains.debugger.Variable; -import org.jetbrains.debugger.VariablesHost; +import com.intellij.util.SmartList +import org.jetbrains.concurrency.Obsolescent +import org.jetbrains.concurrency.ObsolescentAsyncFunction +import org.jetbrains.concurrency.Promise +import org.jetbrains.debugger.EvaluateContext +import org.jetbrains.debugger.Variable +import org.jetbrains.debugger.VariablesHost +import org.jetbrains.debugger.Vm +import java.util.* -import java.util.Collections; -import java.util.Comparator; -import java.util.List; +abstract class ObjectValueBase>(type: ValueType) : ValueBase(type), ObjectValue { + protected abstract val childrenManager: VariablesHost -public abstract class ObjectValueBase extends ValueBase implements ObjectValue { - protected VariablesHost childrenManager; + override val properties: Promise> + get() = childrenManager.get() - public ObjectValueBase(@NotNull ValueType type) { - super(type); + internal abstract inner class MyObsolescentAsyncFunction(private val obsolescent: Obsolescent) : ObsolescentAsyncFunction { + override fun isObsolete() = obsolescent.isObsolete || childrenManager.valueManager.isObsolete } - @NotNull - @Override - public final Promise> getProperties() { - return childrenManager.get(); - } + override fun getProperties(names: List, evaluateContext: EvaluateContext, obsolescent: Obsolescent) = properties + .then(object : MyObsolescentAsyncFunction, List>(obsolescent) { + override fun `fun`(variables: List) = getSpecifiedProperties(variables, names, evaluateContext) + }) - abstract class MyObsolescentAsyncFunction implements ObsolescentAsyncFunction { - private final Obsolescent obsolescent; + override val valueString: String? = null - MyObsolescentAsyncFunction(@NotNull Obsolescent obsolescent) { - this.obsolescent = obsolescent; - } + override fun getIndexedProperties(from: Int, to: Int, bucketThreshold: Int, consumer: IndexedVariablesConsumer, componentType: ValueType?): Promise<*> = Promise.REJECTED - @Override - public boolean isObsolete() { - return obsolescent.isObsolete() || childrenManager.valueManager.isObsolete(); - } - } + @Suppress("CAST_NEVER_SUCCEEDS") + override val variablesHost: VariablesHost> + get() = childrenManager as VariablesHost> - @NotNull - @Override - public Promise> getProperties(@NotNull final List names, @NotNull final EvaluateContext evaluateContext, @NotNull final Obsolescent obsolescent) { - return getProperties() - .then(new MyObsolescentAsyncFunction, List>(obsolescent) { - @NotNull - @Override - public Promise> fun(List variables) { - return getSpecifiedProperties(variables, names, evaluateContext); + companion object { + protected fun getSpecifiedProperties(variables: List, names: List, evaluateContext: EvaluateContext): Promise> { + val properties = SmartList() + var getterCount = 0 + for (property in variables) { + if (!property.isReadable || !names.contains(property.name)) { + continue } - }); - } - @NotNull - protected static Promise> getSpecifiedProperties(@NotNull List variables, @NotNull final List names, @NotNull EvaluateContext evaluateContext) { - final List properties = new SmartList(); - int getterCount = 0; - for (Variable property : variables) { - if (!property.isReadable() || !names.contains(property.getName())) { - continue; + if (!properties.isEmpty()) { + Collections.sort(properties, object : Comparator { + override fun compare(o1: Variable, o2: Variable) = names.indexOf(o1.name) - names.indexOf(o2.name) + }) + } + + properties.add(property) + if (property.value == null) { + getterCount++ + } } - if (!properties.isEmpty()) { - Collections.sort(properties, new Comparator() { - @Override - public int compare(@NotNull Variable o1, @NotNull Variable o2) { - return names.indexOf(o1.getName()) - names.indexOf(o2.getName()); + if (getterCount == 0) { + return Promise.resolve(properties) + } + else { + val promises = SmartList>() + for (variable in properties) { + if (variable.value == null) { + val valueModifier = variable.valueModifier + assert(valueModifier != null) + promises.add(valueModifier!!.evaluateGet(variable, evaluateContext)) } - }); - } - - properties.add(property); - if (property.getValue() == null) { - getterCount++; - } - } - - if (getterCount == 0) { - return Promise.resolve(properties); - } - else { - List> promises = new SmartList>(); - for (Variable variable : properties) { - if (variable.getValue() == null) { - ValueModifier valueModifier = variable.getValueModifier(); - assert valueModifier != null; - promises.add(valueModifier.evaluateGet(variable, evaluateContext)); } + return Promise.all>(promises, properties) } - return Promise.all(promises, properties); } } - - @Nullable - @Override - public String getValueString() { - return null; - } - - @NotNull - @Override - public ThreeState hasProperties() { - return ThreeState.UNSURE; - } - - @NotNull - @Override - public ThreeState hasIndexedProperties() { - return ThreeState.NO; - } - - @NotNull - @Override - public Promise getIndexedProperties(int from, int to, int bucketThreshold, @NotNull IndexedVariablesConsumer consumer, @Nullable ValueType componentType) { - return Promise.REJECTED; - } - - @NotNull - @Override - public VariablesHost getVariablesHost() { - return childrenManager; - } } \ No newline at end of file diff --git a/platform/script-debugger/backend/src/org/jetbrains/debugger/values/Value.java b/platform/script-debugger/backend/src/org/jetbrains/debugger/values/Value.java index c64d1e090795..7c8ec35576e5 100755 --- a/platform/script-debugger/backend/src/org/jetbrains/debugger/values/Value.java +++ b/platform/script-debugger/backend/src/org/jetbrains/debugger/values/Value.java @@ -1,16 +1,13 @@ -package org.jetbrains.debugger.values; - -import org.jetbrains.annotations.NotNull; +package org.jetbrains.debugger.values /** * An object that represents a VM variable value (compound or atomic). */ -public interface Value { - @NotNull - ValueType getType(); +interface Value { + val type: ValueType /** * @return a string representation of this value */ - String getValueString(); + val valueString: String? } diff --git a/platform/script-debugger/backend/src/org/jetbrains/debugger/values/ValueBase.java b/platform/script-debugger/backend/src/org/jetbrains/debugger/values/ValueBase.java index fd8cc9c93615..a97684a3522e 100644 --- a/platform/script-debugger/backend/src/org/jetbrains/debugger/values/ValueBase.java +++ b/platform/script-debugger/backend/src/org/jetbrains/debugger/values/ValueBase.java @@ -1,17 +1,3 @@ -package org.jetbrains.debugger.values; +package org.jetbrains.debugger.values -import org.jetbrains.annotations.NotNull; - -public abstract class ValueBase implements Value { - protected final ValueType type; - - public ValueBase(@NotNull ValueType type) { - this.type = type; - } - - @NotNull - @Override - public final ValueType getType() { - return type; - } -} \ No newline at end of file +abstract class ValueBase(override val type: ValueType) : Value \ No newline at end of file diff --git a/platform/script-debugger/backend/src/org/jetbrains/rpc/CommandProcessor.java b/platform/script-debugger/backend/src/org/jetbrains/rpc/CommandProcessor.java index ea20491884da..2614dcaf8697 100644 --- a/platform/script-debugger/backend/src/org/jetbrains/rpc/CommandProcessor.java +++ b/platform/script-debugger/backend/src/org/jetbrains/rpc/CommandProcessor.java @@ -1,44 +1,30 @@ -package org.jetbrains.rpc; +package org.jetbrains.rpc -import com.intellij.openapi.diagnostic.Logger; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jsonProtocol.Request; +import com.intellij.openapi.diagnostic.Logger +import org.jetbrains.jsonProtocol.Request +import java.util.concurrent.atomic.AtomicInteger -import java.util.concurrent.atomic.AtomicInteger; +val LOG = Logger.getInstance(CommandProcessor::class.java) -public abstract class CommandProcessor - extends CommandSenderBase - implements MessageManager.Handler, - ResultReader, - MessageProcessor { - public static final Logger LOG = Logger.getInstance(CommandProcessor.class); +abstract class CommandProcessor() : CommandSenderBase(), MessageManager.Handler, INCOMING, INCOMING_WITH_SEQ, SUCCESS_RESPONSE>, ResultReader, MessageProcessor { + private val currentSequence = AtomicInteger() + protected val messageManager = MessageManager(this) - private final AtomicInteger currentSequence = new AtomicInteger(); - protected final MessageManager messageManager; - - protected CommandProcessor() { - messageManager = new MessageManager(this); + override fun cancelWaitingRequests() { + messageManager.cancelWaitingRequests() } - @Override - public final void cancelWaitingRequests() { - messageManager.cancelWaitingRequests(); + override fun closed() { + messageManager.closed() } - @Override - public final void closed() { - messageManager.closed(); + override fun getUpdatedSequence(message: Request): Int { + val id = currentSequence.incrementAndGet() + message.finalize(id) + return id } - @Override - public final int getUpdatedSequence(@NotNull Request message) { - int id = currentSequence.incrementAndGet(); - message.finalize(id); - return id; - } - - @Override - protected void send(@NotNull Request message, @NotNull RequestPromise callback) { - messageManager.send(message, callback); + override final fun doSend(message: Request, callback: CommandSenderBase.RequestPromise) { + messageManager.send(message, callback) } } \ No newline at end of file diff --git a/platform/script-debugger/backend/src/org/jetbrains/rpc/CommandSenderBase.java b/platform/script-debugger/backend/src/org/jetbrains/rpc/CommandSenderBase.java index 41ecacf14420..c9c799014f4f 100644 --- a/platform/script-debugger/backend/src/org/jetbrains/rpc/CommandSenderBase.java +++ b/platform/script-debugger/backend/src/org/jetbrains/rpc/CommandSenderBase.java @@ -1,49 +1,43 @@ -package org.jetbrains.rpc; +package org.jetbrains.rpc -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.concurrency.AsyncPromise; -import org.jetbrains.concurrency.Promise; -import org.jetbrains.jsonProtocol.Request; +import org.jetbrains.concurrency.AsyncPromise +import org.jetbrains.concurrency.Promise +import org.jetbrains.jsonProtocol.Request -public abstract class CommandSenderBase implements CommandSender { - protected abstract void send(@NotNull Request message, @NotNull RequestPromise callback); +abstract class CommandSenderBase { + protected abstract fun doSend(message: Request, callback: RequestPromise) - @Override - @NotNull - public final Promise send(@NotNull Request request) { - RequestPromise callback = new RequestPromise(request.getMethodName()); - send(request, callback); - return callback; + fun send(message: Request): Promise { + val callback = RequestPromise(message.methodName) + doSend(message, callback) + return callback } - protected static final class RequestPromise extends AsyncPromise implements RequestCallback { - private final String methodName; - - public RequestPromise(@Nullable String methodName) { - this.methodName = methodName; - } - - @Override - public void onSuccess(@Nullable SUCCESS_RESPONSE response, @Nullable ResultReader resultReader) { + protected class RequestPromise(private val methodName: String?) : AsyncPromise(), RequestCallback { + @Suppress("BASE_WITH_NULLABLE_UPPER_BOUND") + override fun onSuccess(response: SUCCESS_RESPONSE?, resultReader: ResultReader?) { try { if (resultReader == null || response == null) { - //noinspection unchecked - setResult((RESULT)response); + @Suppress("UNCHECKED_CAST") + setResult(response as RESULT) } else { - setResult(methodName == null ? null : resultReader.readResult(methodName, response)); + if (methodName == null) { + setResult(null) + } + else { + setResult(resultReader.readResult(methodName, response)) + } } } - catch (Throwable e) { - CommandProcessor.LOG.error(e); - setError(e); + catch (e: Throwable) { + LOG.error(e) + setError(e) } } - @Override - public void onError(@NotNull Throwable error) { - setError(error); + override fun onError(error: Throwable) { + setError(error) } } } \ No newline at end of file diff --git a/platform/script-debugger/backend/src/org/jetbrains/rpc/MessageManager.java b/platform/script-debugger/backend/src/org/jetbrains/rpc/MessageManager.java index 4421b199b735..820be7cce07f 100644 --- a/platform/script-debugger/backend/src/org/jetbrains/rpc/MessageManager.java +++ b/platform/script-debugger/backend/src/org/jetbrains/rpc/MessageManager.java @@ -13,121 +13,100 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.jetbrains.rpc; +package org.jetbrains.rpc -import com.intellij.util.containers.ConcurrentIntObjectMap; -import com.intellij.util.containers.ContainerUtil; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.concurrency.Promise; +import com.intellij.util.containers.ContainerUtil +import org.jetbrains.concurrency.Promise +import java.io.IOException +import java.util.* -import java.io.IOException; -import java.util.Arrays; +class MessageManager(private val handler: MessageManager.Handler) : MessageManagerBase() { + private val callbackMap = ContainerUtil.createConcurrentIntObjectMap>() -/** - * @param type of outgoing message - * @param type of incoming message - * @param type of incoming message that is a command (has sequence number) - */ -public final class MessageManager extends MessageManagerBase { - private final ConcurrentIntObjectMap> callbackMap = ContainerUtil.createConcurrentIntObjectMap(); - private final Handler handler; + interface Handler { + fun getUpdatedSequence(message: OUTGOING): Int - public MessageManager(Handler handler) { - this.handler = handler; + @Throws(IOException::class) + fun write(message: OUTGOING): Boolean + + fun readIfHasSequence(incoming: INCOMING): INCOMING_WITH_SEQ? + + fun getSequence(incomingWithSeq: INCOMING_WITH_SEQ): Int + + fun acceptNonSequence(incoming: INCOMING) + + fun call(response: INCOMING_WITH_SEQ, callback: RequestCallback) } - public interface Handler { - int getUpdatedSequence(@NotNull OUTGOING message); - - boolean write(@NotNull OUTGOING message) throws IOException; - - INCOMING_WITH_SEQ readIfHasSequence(INCOMING incoming); - - int getSequence(INCOMING_WITH_SEQ incomingWithSeq); - - void acceptNonSequence(INCOMING incoming); - - void call(INCOMING_WITH_SEQ response, RequestCallback callback); - } - - public void send(@NotNull REQUEST message, @NotNull RequestCallback callback) { + fun send(message: REQUEST, callback: RequestCallback) { if (rejectIfClosed(callback)) { - return; + return } - int sequence = handler.getUpdatedSequence(message); - callbackMap.put(sequence, callback); - - boolean success; + val sequence = handler.getUpdatedSequence(message) + callbackMap.put(sequence, callback) + + val success: Boolean try { - success = handler.write(message); + success = handler.write(message) } - catch (Throwable e) { + catch (e: Throwable) { try { - failedToSend(sequence); + failedToSend(sequence) } finally { - CommandProcessor.LOG.error("Failed to send", e); + LOG.error("Failed to send", e) } - return; + return } if (!success) { - failedToSend(sequence); + failedToSend(sequence) } } - private void failedToSend(int sequence) { - RequestCallback callback = callbackMap.remove(sequence); - if (callback != null) { - callback.onError(Promise.createError("Failed to send")); - } + private fun failedToSend(sequence: Int) { + callbackMap.remove(sequence)?.onError(Promise.createError("Failed to send")) } - public void processIncoming(INCOMING incomingParsed) { - INCOMING_WITH_SEQ commandResponse = handler.readIfHasSequence(incomingParsed); + fun processIncoming(incomingParsed: INCOMING) { + val commandResponse = handler.readIfHasSequence(incomingParsed) if (commandResponse == null) { if (closed) { // just ignore - CommandProcessor.LOG.info("Connection closed, ignore incoming"); + LOG.info("Connection closed, ignore incoming") } else { - handler.acceptNonSequence(incomingParsed); + handler.acceptNonSequence(incomingParsed) } - return; + return } - RequestCallback callback = getCallbackAndRemove(handler.getSequence(commandResponse)); + val callback = getCallbackAndRemove(handler.getSequence(commandResponse)) if (rejectIfClosed(callback)) { - return; + return } try { - handler.call(commandResponse, callback); + handler.call(commandResponse, callback) } - catch (Throwable e) { - callback.onError(e); - CommandProcessor.LOG.error("Failed to dispatch response to callback", e); + catch (e: Throwable) { + callback.onError(e) + LOG.error("Failed to dispatch response to callback", e) } } - public RequestCallback getCallbackAndRemove(int id) { - RequestCallback callback = callbackMap.remove(id); - if (callback == null) { - throw new IllegalArgumentException("Cannot find callback with id " + id); - } - return callback; - } + fun getCallbackAndRemove(id: Int) = callbackMap.remove(id) ?: throw IllegalArgumentException("Cannot find callback with id $id") - public void cancelWaitingRequests() { + fun cancelWaitingRequests() { // we should call them in the order they have been submitted - ConcurrentIntObjectMap> map = callbackMap; - int[] keys = map.keys(); - Arrays.sort(keys); - for (int key : keys) { - RequestCallback callback = map.get(key); + val map = callbackMap + val keys = map.keys() + Arrays.sort(keys) + for (key in keys) { + val callback = map.get(key) if (callback != null) { - rejectCallback(callback); + MessageManagerBase.rejectCallback(callback) } } } diff --git a/platform/script-debugger/backend/src/org/jetbrains/rpc/MessageManagerBase.java b/platform/script-debugger/backend/src/org/jetbrains/rpc/MessageManagerBase.java index 079aa83b4684..03c61a90f9f9 100644 --- a/platform/script-debugger/backend/src/org/jetbrains/rpc/MessageManagerBase.java +++ b/platform/script-debugger/backend/src/org/jetbrains/rpc/MessageManagerBase.java @@ -1,24 +1,25 @@ -package org.jetbrains.rpc; +package org.jetbrains.rpc -import org.jetbrains.annotations.NotNull; -import org.jetbrains.concurrency.Promise; +import org.jetbrains.concurrency.Promise -public abstract class MessageManagerBase { - protected volatile boolean closed; +abstract class MessageManagerBase { + @Volatile protected var closed = false - protected final boolean rejectIfClosed(RequestCallback callback) { + protected fun rejectIfClosed(callback: RequestCallback<*>): Boolean { if (closed) { - callback.onError(Promise.createError("Connection closed")); - return true; + callback.onError(Promise.createError("Connection closed")) + return true } - return false; + return false } - public final void closed() { - closed = true; + fun closed() { + closed = true } - protected static void rejectCallback(@NotNull RequestCallback callback) { - callback.onError(Promise.createError("Connection closed")); + companion object { + protected fun rejectCallback(callback: RequestCallback<*>) { + callback.onError(Promise.createError("Connection closed")) + } } } \ No newline at end of file diff --git a/platform/script-debugger/backend/src/org/jetbrains/rpc/MessageProcessor.java b/platform/script-debugger/backend/src/org/jetbrains/rpc/MessageProcessor.java index 719d8b033040..7c5523090ab2 100644 --- a/platform/script-debugger/backend/src/org/jetbrains/rpc/MessageProcessor.java +++ b/platform/script-debugger/backend/src/org/jetbrains/rpc/MessageProcessor.java @@ -1,14 +1,12 @@ -package org.jetbrains.rpc; +package org.jetbrains.rpc -import org.jetbrains.annotations.NotNull; -import org.jetbrains.concurrency.Promise; -import org.jetbrains.jsonProtocol.Request; +import org.jetbrains.concurrency.Promise +import org.jetbrains.jsonProtocol.Request -public interface MessageProcessor { - void cancelWaitingRequests(); +interface MessageProcessor { + fun cancelWaitingRequests() - void closed(); + fun closed() - @NotNull - Promise send(@NotNull Request message); + fun send(message: Request): Promise } \ No newline at end of file diff --git a/platform/script-debugger/backend/src/org/jetbrains/rpc/MessageWriter.java b/platform/script-debugger/backend/src/org/jetbrains/rpc/MessageWriter.java index 07dbee19f922..690f8cf9f3c2 100644 --- a/platform/script-debugger/backend/src/org/jetbrains/rpc/MessageWriter.java +++ b/platform/script-debugger/backend/src/org/jetbrains/rpc/MessageWriter.java @@ -1,26 +1,21 @@ -package org.jetbrains.rpc; +package org.jetbrains.rpc -import com.intellij.openapi.vfs.CharsetToolkit; -import com.intellij.util.BooleanFunction; -import io.netty.buffer.ByteBuf; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jsonProtocol.Request; +import com.intellij.openapi.vfs.CharsetToolkit +import com.intellij.util.BooleanFunction +import io.netty.buffer.ByteBuf +import org.jetbrains.jsonProtocol.Request -import static org.jetbrains.rpc.CommandProcessor.LOG; - -public abstract class MessageWriter implements BooleanFunction { - @Override - public boolean fun(@NotNull Request message) { - ByteBuf content = message.getBuffer(); - if (isDebugLoggingEnabled()) { - LOG.debug("OUT: " + content.toString(CharsetToolkit.UTF8_CHARSET)); +abstract class MessageWriter : BooleanFunction> { + override fun `fun`(message: Request): Boolean { + val content = message.buffer + if (isDebugLoggingEnabled) { + LOG.debug("OUT: ${content.toString(CharsetToolkit.UTF8_CHARSET)}") } - return write(content); + return write(content) } - protected boolean isDebugLoggingEnabled() { - return LOG.isDebugEnabled(); - } + protected open val isDebugLoggingEnabled: Boolean + get() = LOG.isDebugEnabled - protected abstract boolean write(@NotNull ByteBuf content); + protected abstract fun write(content: ByteBuf): Boolean } \ No newline at end of file diff --git a/platform/script-debugger/backend/src/org/jetbrains/rpc/RequestCallback.java b/platform/script-debugger/backend/src/org/jetbrains/rpc/RequestCallback.java index 409cff797923..530aa7c586d2 100644 --- a/platform/script-debugger/backend/src/org/jetbrains/rpc/RequestCallback.java +++ b/platform/script-debugger/backend/src/org/jetbrains/rpc/RequestCallback.java @@ -1,10 +1,8 @@ -package org.jetbrains.rpc; +package org.jetbrains.rpc -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; +@Suppress("BASE_WITH_NULLABLE_UPPER_BOUND") +interface RequestCallback { + fun onSuccess(response: SUCCESS_RESPONSE?, resultReader: ResultReader?) -public interface RequestCallback { - void onSuccess(@Nullable SUCCESS_RESPONSE successResponse, @Nullable ResultReader resultReader); - - void onError(@NotNull Throwable error); + fun onError(error: Throwable) } \ No newline at end of file diff --git a/platform/script-debugger/backend/src/org/jetbrains/rpc/ResultReader.java b/platform/script-debugger/backend/src/org/jetbrains/rpc/ResultReader.java index 4bb055c754d2..5aeb94e0c369 100644 --- a/platform/script-debugger/backend/src/org/jetbrains/rpc/ResultReader.java +++ b/platform/script-debugger/backend/src/org/jetbrains/rpc/ResultReader.java @@ -1,7 +1,5 @@ -package org.jetbrains.rpc; +package org.jetbrains.rpc -import org.jetbrains.annotations.NotNull; - -public interface ResultReader { - RESULT readResult(@NotNull String readMethodName, @NotNull RESPONSE successResponse); +interface ResultReader { + fun readResult(readMethodName: String, successResponse: RESPONSE): RESULT } \ No newline at end of file diff --git a/platform/script-debugger/debugger-ui/src/org/jetbrains/debugger/ValueNodeAsyncFunction.java b/platform/script-debugger/debugger-ui/src/org/jetbrains/debugger/ValueNodeAsyncFunction.java index 15d685b492f9..e9340f483d94 100644 --- a/platform/script-debugger/debugger-ui/src/org/jetbrains/debugger/ValueNodeAsyncFunction.java +++ b/platform/script-debugger/debugger-ui/src/org/jetbrains/debugger/ValueNodeAsyncFunction.java @@ -13,21 +13,21 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.jetbrains.debugger; +package org.jetbrains.debugger -import org.jetbrains.annotations.NotNull; -import org.jetbrains.concurrency.AsyncFunction; -import org.jetbrains.concurrency.Obsolescent; +import org.jetbrains.concurrency.AsyncFunction +import org.jetbrains.concurrency.Obsolescent +import org.jetbrains.concurrency.Promise -public abstract class ValueNodeAsyncFunction implements AsyncFunction, Obsolescent { - private final Obsolescent node; - - protected ValueNodeAsyncFunction(@NotNull Obsolescent node) { - this.node = node; - } - - @Override - public final boolean isObsolete() { - return node.isObsolete(); - } +abstract class ValueNodeAsyncFunction protected constructor(private val node: Obsolescent) : AsyncFunction, Obsolescent { + override fun isObsolete() = node.isObsolete } + +inline fun Promise.thenAsync(node: Obsolescent, crossinline handler: (T) -> Promise) = then(object : ValueNodeAsyncFunction(node) { + override fun `fun`(param: T) = handler(param) +}) + +@Suppress("UNCHECKED_CAST") +inline fun Promise.thenAsyncVoid(node: Obsolescent, crossinline handler: (T) -> Promise<*>) = then(object : ValueNodeAsyncFunction(node) { + override fun `fun`(param: T) = handler(param) as Promise +}) \ No newline at end of file