javonet-ruby-sdk 2.1.12 → 2.1.13

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/protocol/CommandDeserializer.js

@@ -0,0 +1,160 @@
+const TypeDeserializer = require("./TypeDeserializer")
+const Command = require("../../utils/Command")
+const Type = require("../../utils/Type")
+const StringEncodingMode = require("../../utils/StringEncodingMode")
+
+
+class CommandDeserializer {
+    constructor(buffer) {
+        this.buffer = buffer
+        this.command = new Command(
+            buffer[0],
+            buffer[10],
+            []
+        )
+        this.position = 11
+    }
+
+    deserialize() {
+        while (!this.isAtEnd()) {
+            this.command = this.command.addArgToPayload((this.readObject(this.buffer[this.position])))
+        }
+        return this.command
+    }
+
+    isAtEnd() {
+        return this.position === this.buffer.length
+    }
+
+    readObject(typeNum) {
+        let type = Object.entries(Type).find(entry => entry[1] === typeNum)[0]
+        switch (type) {
+            case 'JAVONET_COMMAND':
+                return this.readCommand()
+            case 'JAVONET_STRING':
+                return this.readString()
+            case 'JAVONET_INTEGER':
+                return this.readInt()
+            case 'JAVONET_BOOLEAN':
+                return this.readBool();
+            case 'JAVONET_FLOAT':
+                return this.readFloat();
+            case 'JAVONET_BYTE':
+                return this.readByte();
+            case 'JAVONET_CHAR':
+                return this.readChar();
+            case 'JAVONET_LONG_LONG':
+                return this.readLongLong();
+            case 'JAVONET_DOUBLE':
+                return this.readDouble();
+            case 'JAVONET_UNSIGNED_LONG_LONG':
+                return this.readUllong
+            case 'JAVONET_UNSIGNED_INTEGER':
+                return this.readUInt()
+            default:
+                throw 'Unknown type - not supported in JavaScript'
+        }
+    }
+
+    readCommand() {
+        let p = this.position
+        let numberOfElementsInPayload = TypeDeserializer.deserializeInt(this.buffer.slice(p + 1, p + 5))
+        let runtime = this.buffer[p + 5]
+        let type = this.buffer[p + 6]
+        this.position += 7
+        let command = new Command(runtime, type, [])
+        return this.readCommandRecursively(numberOfElementsInPayload, command)
+    }
+
+    readCommandRecursively(numberOfElementsInPayloadLeft, cmd) {
+        if (numberOfElementsInPayloadLeft === 0) return cmd
+        let p = this.position
+        cmd = cmd.addArgToPayload(this.readObject(this.buffer[p]))
+        return this.readCommandRecursively(numberOfElementsInPayloadLeft - 1, cmd)
+    }
+
+    readString() {
+        let p = this.position
+        let stringEncodingMode = this.buffer[p + 1]
+        let size = TypeDeserializer.deserializeInt(this.buffer.slice(p + 2, p + 6))
+        this.position += 6
+        p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeString(stringEncodingMode, this.buffer.slice(p, p + size))
+
+    }
+
+    readInt() {
+        let size = 4
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeInt(this.buffer.slice(p, p + size))
+    }
+
+    readBool() {
+        let size = 1
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeBool(this.buffer.slice(p, p + size))
+    }
+
+    readFloat() {
+        let size = 4
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeFloat(this.buffer.slice(p, p + size))
+    }
+
+    readByte() {
+        let size = 1
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeByte(this.buffer.slice(p, p + size))
+    }
+
+    readChar() {
+        let size = 1
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeChar(this.buffer.slice(p, p + size))
+    }
+
+    readLongLong() {
+        let size = 8
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeLongLong(this.buffer.slice(p, p + size))
+    }
+
+    readDouble() {
+        let size = 8
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeDouble(this.buffer.slice(p, p + size))
+    }
+
+    readUllong() {
+        let size = 8
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeULLong(this.buffer.slice(p, p + size))
+    }
+
+    readUInt() {
+        let size = 4
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeUInt(this.buffer.slice(p, p + size))
+    }
+}
+
+module.exports = CommandDeserializer

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/protocol/{CommandEncoder.js → CommandSerializer.js}

@@ -1,13 +1,13 @@
 const Command = require("../../utils/Command")
-const TypeEncoder = require('./TypeEncoder')
+const TypeEncoder = require('./TypeSerializer')
 const ConnectionType = require("../../utils/ConnectionType");
 const Runtime = require('../../utils/RuntimeName')
 
-class CommandEncoder {
+class CommandSerializer {
     buffer = new Int8Array(2)
     encodedTcp;
 
-    encode(command, connectionType, tcpConnectionData, runtimeVersion = 0) {
+    serialize(command, connectionType, tcpConnectionData, runtimeVersion = 0) {
         let deque = [command]
         this.buffer[0] = command.runtimeName
         this.buffer[1] = runtimeVersion
@@ -48,7 +48,7 @@ class CommandEncoder {
         if (cmd.payload.length > 0) {
             if (cmd.payload[0] instanceof Command) {
                 let innerCommand = cmd.payload[0]
-                this.#insertIntoBuffer(TypeEncoder.encodeCommand(innerCommand))
+                this.#insertIntoBuffer(TypeEncoder.serializeCommand(innerCommand))
                 deque.push(innerCommand)
             } else {
                 let result = TypeEncoder.encodePrimitive(cmd.payload[0])
@@ -69,4 +69,4 @@ class CommandEncoder {
     }
 }
 
-module.exports = CommandEncoder
+module.exports = CommandSerializer

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/protocol/TypeDeserializer.js

@@ -0,0 +1,77 @@
+const Command = require('../../utils/Command')
+const Type = require('../../utils/Type')
+const StringEncodingMode = require('../../utils/StringEncodingMode')
+const {TextDecoder} = require("util");
+
+class TypeDeserializer {
+    static deserializeCommand(encodedCommand) {
+        return new Command(encodedCommand[0], encodedCommand[1], [])
+    }
+
+    static deserializeString(stringEncodingMode, encodedString) {
+        switch (stringEncodingMode) {
+            case StringEncodingMode.ASCII:
+                return String.fromCharCode(...encodedString)
+            case StringEncodingMode.UTF8:
+                let decoder = new TextDecoder('UTF-8');
+                return decoder.decode(new Uint8Array(encodedString))
+            case StringEncodingMode.UTF16:
+                let str = "";
+                let newBuffer = new Uint8Array(encodedString)
+                for (let i = 0; i < newBuffer.length; i++) {
+                    newBuffer[i] = encodedString[i]
+                }
+                for (let i = 0; i < encodedString.length; i = i + 2) {
+                    str += String.fromCharCode(newBuffer[i] + 256 * newBuffer[i + 1])
+                }
+                return str;
+            case StringEncodingMode.UTF32:
+                throw "Type utf32-encoded string not supported in JavaScript"
+            default:
+                throw "Unknown string encoding - not supported in JavaScript";
+        }
+    }
+
+    static deserializeInt(encodedInt) {
+        return (
+            (encodedInt[0] & 0xFF)
+            | ((encodedInt[1] & 0xFF) << 8)
+            | ((encodedInt[2] & 0xFF) << 16)
+            | ((encodedInt[3] & 0xFF) << 24)
+        )
+    }
+
+    static deserializeBool(encodedBool) {
+        return encodedBool[0] === 1
+    }
+
+    static deserializeFloat(encodedFloat) {
+        return Buffer.from(encodedFloat).readFloatLE()
+    }
+
+    static deserializeByte(encodedByte) {
+        return Buffer.from(encodedByte).readUint8()
+    }
+
+    static deserializeChar(encodedChar) {
+        return Buffer.from(encodedChar).readUint8()
+    }
+
+    static deserializeLongLong(encodedLongLong) {
+        return Buffer.from(encodedLongLong).readBigInt64LE()
+    }
+
+    static deserializeDouble(encodedDouble) {
+        return Buffer.from(encodedDouble).readDoubleLE()
+    }
+
+    static deserializeULLong(encodedULLong) {
+        return Buffer.from(encodedULLong).readBigUInt64LE()
+    }
+
+    static deserializeUInt(encodedUInt) {
+        return Buffer.from(encodedUInt).readUIntLE(0, 4)
+    }
+}
+
+module.exports = TypeDeserializer

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/protocol/TypeSerializer.js

@@ -0,0 +1,126 @@
+const Command = require('../../utils/Command')
+const Type = require('../../utils/Type')
+const StringEncodingMode = require('../../utils/StringEncodingMode')
+
+const util = require('util');
+let encoder = new util.TextEncoder();
+
+class TypeSerializer {
+
+    static encodePrimitive(payload_item) {
+        if (payload_item instanceof Command) {
+            return TypeSerializer.serializeCommand(payload_item)
+        } else if (typeof (payload_item) === 'number' || payload_item instanceof Number) {
+            if (Number.isInteger(payload_item)) {
+                return TypeSerializer.serializeInt(payload_item)
+            } else {
+                return TypeSerializer.serializeDouble(payload_item)
+            }
+        } else if (typeof (payload_item) === 'string' || payload_item instanceof String) {
+            return TypeSerializer.serializeString(payload_item)
+        } else if (typeof (payload_item) === 'boolean' || payload_item instanceof Boolean) {
+            return TypeSerializer.serializeBool(payload_item)
+        } else {
+            throw 'Unknown type - not supported in JavaScript'
+        }
+    }
+
+    static serializeCommand(command) {
+        const buffer = Buffer.alloc(7, command)
+        buffer.writeUInt8(Type.JAVONET_COMMAND, 0)
+        buffer.fill(Buffer.from(this.serializeIntValue(command.payload.length)), 1, 5)
+        buffer.writeUInt8(command.runtime, 5)
+        buffer.writeUInt8(command.commandType, 6)
+        return buffer
+    }
+
+    static serializeString(string_value) {
+        let bytes = encoder.encode(string_value)
+        const buffer = Buffer.alloc(6 + bytes.length)
+        buffer.writeUInt8(Type.JAVONET_STRING, 0)
+        buffer.writeUInt8(StringEncodingMode.UTF8, 1)
+        buffer.fill(Buffer.from(this.serializeIntValue(bytes.length)), 2, 6)
+        buffer.fill(Buffer.from(bytes), 6, 6 + bytes.length)
+        return buffer
+    }
+
+    static serializeInt(int_value) {
+        const buffer = Buffer.alloc(6)
+        buffer.writeUInt8(Type.JAVONET_INTEGER, 0)
+        buffer.writeUInt8(4, 1)
+        buffer.writeInt32LE(int_value, 2)
+        return buffer
+    }
+
+    static serializeBool(bool_value) {
+        const buffer = Buffer.alloc(3)
+        buffer.writeUInt8(Type.JAVONET_BOOLEAN, 0)
+        buffer.writeUInt8(1, 1)
+        buffer.writeUInt8(bool_value ? 1 : 0, 2)
+        return buffer
+    }
+
+    static serializeFloat(float_value) {
+        const buffer = Buffer.alloc(6)
+        buffer.writeUInt8(Type.JAVONET_FLOAT, 0)
+        buffer.writeUInt8(4, 1)
+        buffer.writeFloatLE(float_value, 2)
+        return buffer
+    }
+
+    static serializeByte(byte_value) {
+        const buffer = Buffer.alloc(3)
+        buffer.writeUInt8(Type.JAVONET_BYTE, 0)
+        buffer.writeUInt8(1, 1)
+        buffer.writeUInt8(byte_value, 2)
+        return buffer
+    }
+
+    static serializeChar(char_value) {
+        const buffer = Buffer.alloc(3)
+        buffer.writeUInt8(Type.JAVONET_CHAR, 0)
+        buffer.writeUInt8(1, 1)
+        buffer.writeUInt8(char_value, 2)
+        return buffer
+    }
+
+    static serializeLongLong(longlong_value) {
+        const buffer = Buffer.alloc(10)
+        buffer.writeUInt8(Type.JAVONET_LONG_LONG, 0)
+        buffer.writeUInt8(8, 1)
+        buffer.writeBigInt64LE(BigInt(longlong_value), 2)
+        return buffer
+    }
+
+    static serializeDouble(double_value) {
+        const buffer = Buffer.alloc(10)
+        buffer.writeUInt8(Type.JAVONET_DOUBLE, 0)
+        buffer.writeUInt8(8, 1)
+        buffer.writeDoubleLE(double_value, 2)
+        return buffer
+    }
+
+    static serializeULLong(ullong_value) {
+        const buffer = Buffer.alloc(10)
+        buffer.writeUInt8(Type.JAVONET_UNSIGNED_LONG_LONG, 0)
+        buffer.writeUInt8(8, 1)
+        buffer.writeBigUInt64LE(ullong_value, 2)
+        return buffer
+    }
+
+    static serializeUInt(uint_value) {
+        const buffer = Buffer.alloc(6)
+        buffer.writeUInt8(Type.JAVONET_UNSIGNED_INTEGER, 0)
+        buffer.writeUInt8(4, 1)
+        buffer.writeUInt32LE(uint_value, 2)
+        return buffer
+    }
+
+    static serializeIntValue(int_value) {
+        const buffer = Buffer.alloc(4)
+        buffer.writeInt32LE(int_value, 0)
+        return buffer
+    }
+}
+
+module.exports = TypeSerializer

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/receiver/Receiver.js

@@ -1,12 +1,9 @@
 const Interpreter = require('../interpreter/Interpreter')
-const CommandEncoder = require('../protocol/CommandEncoder')
 const interpreter = new Interpreter()
 
 class Receiver {
     static sendCommand(byteArray) {
-        let command = interpreter.process(byteArray)
-        let commandEncoder = new CommandEncoder()
-        return commandEncoder.encode(command, 0, 0)
+        return interpreter.process(byteArray)
     }
     static heartBeat(byteArray) {
         return Int8Array.from([49, 48])