javonet-nodejs-sdk 2.0.5 → 2.1.1

package/lib/core/handler/InvokeStaticMethodHandler.js

@@ -6,12 +6,15 @@ class InvokeStaticMethodHandler extends AbstractHandler {
     }
 
     process(command) {
-        const { payload } = command
-        let type = payload[0]
-        let methodName = payload[1]
-        let args = payload.slice(2)
-        
-        return Reflect.apply(type[methodName], undefined, args)
+        try {
+            const {payload} = command
+            let type = payload[0]
+            let methodName = payload[1]
+            let args = payload.slice(2)
+            return Reflect.apply(type[methodName], undefined, args)
+        } catch (error) {
+            return this.process_stack_trace(error, this.constructor.name)
+        }
     }
 }
 

package/lib/core/handler/LoadLibraryHandler.js

@@ -13,11 +13,11 @@ class LoadLibraryHandler extends AbstractHandler {
         libraryName = libraryName.replace('.js', '')
         try {
             global[libraryName] = require(lib)
-        } catch(error) {
+        } catch (error) {
             try {
                 global[libraryName] = require(`${process.cwd()}/${lib}`)
             } catch {
-                throw `Cannot load ${lib}`
+                return this.process_stack_trace(error, this.constructor.name)
             }
         }
         return 0

package/lib/core/handler/ValueHandler.js

@@ -0,0 +1,11 @@
+const AbstractHandler =  require("./AbstractHandler")
+
+
+class ValueHandler extends AbstractHandler {
+    process(command) {
+        const {payload} = command
+        return payload[0]
+    }
+}
+
+module.exports = new ValueHandler()

package/lib/core/interpreter/Interpreter.js

@@ -1,7 +1,7 @@
 const { Handler } = require('../handler/Handler')
 const CommandEncoder = require('../protocol/CommandEncoder')
 const CommandDecoder = require('../protocol/CommandDecoder')
-
+const Runtime = require("../../utils/RuntimeName");
 
 let Transmitter
 
@@ -9,22 +9,27 @@ class Interpreter {
     handler = new Handler()
 
     execute(command, connectionType, tcpAddress) {
-        // lazy transmitter loading
-        if(!Transmitter) {
-            Transmitter = require('../transmitter/NodejsTransmitter')
-        }
-
-        let encoder = new CommandEncoder()
-        let byteMessage = encoder.encode(command,connectionType, tcpAddress)
+        let commandEncoder = new CommandEncoder()
+        let byteMessage = commandEncoder.encode(command,connectionType, tcpAddress)
+        let responseByteArray
 
-        let bytes = Transmitter.sendCommand(byteMessage)
-        return new CommandDecoder(bytes).decode()
+        if (command.runtimeName === Runtime.Nodejs)
+        {
+            return this.process(byteMessage)
+        }
+        else {
+            // lazy transmitter loading
+            if (!Transmitter) {
+                Transmitter = require('../transmitter/Transmitter')
+            }
+            responseByteArray = Transmitter.sendCommand(byteMessage)
+            return new CommandDecoder(responseByteArray).decode()
+        }
     }
 
     process(byteArray) {
         let decoder = new CommandDecoder(byteArray)
         let command = decoder.decode()
-
         return this.handler.handleCommand(command)
     }
 }

package/lib/core/protocol/CommandEncoder.js

@@ -1,18 +1,18 @@
 const Command = require("../../utils/Command")
 const TypeEncoder = require('./TypeEncoder')
 const ConnectionType = require("../../utils/ConnectionType");
-const Runtime = require('../../utils/Runtime')
+const Runtime = require('../../utils/RuntimeName')
 
 class CommandEncoder {
     buffer = new Int8Array(2)
     encodedTcp;
 
-    encode(root, connectionType, tcpConnectionData, runtimeVersion = 0) {
-        let deque = [root]
-        this.buffer[0] = root.runtime
+    encode(command, connectionType, tcpConnectionData, runtimeVersion = 0) {
+        let deque = [command]
+        this.buffer[0] = command.runtimeName
         this.buffer[1] = runtimeVersion
         this.#insertIntoBuffer(this.#encodeTcpConnection(connectionType, tcpConnectionData))
-        this.#insertIntoBuffer(new Int8Array([Runtime.Nodejs, root.commandId]))
+        this.#insertIntoBuffer(new Int8Array([Runtime.Nodejs, command.commandType]))
         return this.#encodeRecursively(deque)
     }
 

package/lib/core/protocol/TypeEncoder.js

@@ -27,7 +27,7 @@ class TypeEncoder {
         buffer.writeInt8(Type.JAVONET_COMMAND, 0)
         buffer.fill(Buffer.from(this.encodeInt32Value(cmd.payload.length)), 1, 5)
         buffer.writeInt8(cmd.runtime, 5)
-        buffer.writeInt8(cmd.commandId, 6)
+        buffer.writeInt8(cmd.commandType, 6)
         return Int8Array.from(buffer)
     }
 

package/lib/core/transmitter/{NodejsTransmitter.js → Transmitter.js}

@@ -1,6 +1,6 @@
-const wrapper = require('./NodejsTransmitterWrapper')
+const wrapper = require('./TransmitterWrapper')
 
-class NodejsTransmitter {
+class Transmitter {
 
    static sendCommand(messageArray) {
         return wrapper.sendCommand(messageArray)
@@ -23,4 +23,4 @@ class NodejsTransmitter {
     }
 }
 
-module.exports = NodejsTransmitter
+module.exports = Transmitter

package/lib/core/transmitter/TransmitterWrapper.js

@@ -0,0 +1,25 @@
+let library;
+
+class TransmitterWrapper {
+    static initialize() {
+        if (process.platform === "win32")
+            library = require(`${require('path').resolve(__dirname, '../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`)
+        else if (process.platform === "darwin")
+            library = require(`${require('path').resolve(__dirname, '../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`)
+        else
+            library = require(`${require('path').resolve(__dirname, '../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`)
+        let binariesRootPath = String(`${require('path').resolve(__dirname, '../../../')}`)
+        return library.initializeTransmitter(binariesRootPath)
+    }
+
+    static activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword) {
+        this.initialize()
+        return library.activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword)
+    }
+
+    static sendCommand(messageArray) {
+        return library.sendCommand(messageArray)
+    }
+}
+
+module.exports = TransmitterWrapper

package/lib/sdk/internal/InvocationContext.js

@@ -1,9 +1,7 @@
 const Interpreter = require("../../core/interpreter/Interpreter")
 const Command = require("../../utils/Command")
 const CommandType = require("../../utils/CommandType")
-const Runtime = require("../../utils/Runtime")
-const {Handler} = require("../../core/handler/Handler");
-const CommandEncoder = require('../../core/protocol/CommandEncoder')
+const ExceptionThrower = require("../../core/exception/ExceptionThrower");
 
 class InvocationContext {
     #runtime
@@ -12,7 +10,6 @@ class InvocationContext {
     #currentCommand
     #responseCommand
     #interpreter
-    #handler
     #isExecuted
     #resultValue
 
@@ -24,32 +21,38 @@ class InvocationContext {
         this.#responseCommand = null
         this.#isExecuted = isExecuted
         this.#interpreter = null
-        this.#handler = null
         this.#resultValue = null
     }
 
     destructor() {
-        if (this.#currentCommand.commandId === CommandType.Reference) {
+        if (this.#currentCommand.commandType === CommandType.Reference) {
             this.#currentCommand = new Command(this.#runtime, CommandType.DestructReference, this.#currentCommand.payload)
             this.execute()
         }
     }
 
-    execute() {
-        this.#interpreter = new Interpreter()
+    [Symbol.iterator] = function() {
+        if (this.#currentCommand.commandType != CommandType.Reference) {
+            throw new Error("Object is not iterable")
+        }
+        let position = -1
+        let arraySize = this.getSize().execute().getValue()
 
-        if (this.#currentCommand.runtime === Runtime.Nodejs) {
-            this.#handler = new Handler()
-            this.#responseCommand = this.#handler.handleCommand(this.#currentCommand)
-        } else {
-            this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.#connectionType, this.#tcpAddress)
+        return {
+            next: () => ({value: this.getIndex(++position), done: (position >= arraySize)})
         }
+    }
+
 
-        if (this.#responseCommand.commandId === CommandType.Exception) {
-            throw this.#responseCommand.payload[0]
+    execute() {
+        this.#interpreter = new Interpreter()
+        this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.#connectionType, this.#tcpAddress)
+
+        if (this.#responseCommand.commandType === CommandType.Exception) {
+            ExceptionThrower.throwException(this.#responseCommand)
         }
 
-        if (this.#responseCommand.commandId === CommandType.CreateClassInstance) {
+        if (this.#responseCommand.commandType === CommandType.CreateClassInstance) {
             this.#currentCommand = this.#responseCommand
             this.#isExecuted = true
             return this
@@ -88,19 +91,51 @@ class InvocationContext {
         return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
     }
 
+    getIndex(...args) {
+        let localCommand = new Command(this.#runtime, CommandType.ArrayGetItem, args)
+        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
+    }
+
+    getSize(...args) {
+        let localCommand = new Command(this.#runtime, CommandType.ArrayGetSize, args)
+        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
+    }
+
+    getRank(...args) {
+        let localCommand = new Command(this.#runtime, CommandType.ArrayGetRank, args)
+        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
+    }
+
+    setIndex(...args) {
+        let localCommand = new Command(this.#runtime, CommandType.ArraySetItem, args)
+        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
+    }
+
     getValue() {
         this.#resultValue = this.#currentCommand.payload[0]
         return this.#resultValue;
     }
 
-    #buildCommand = function(command) {
+    #buildCommand = function (command) {
         for (let i = 0; i < command.payload.length; i++) {
-            if (typeof (command.payload[i]) === 'InvocationContext' || command.payload[i] instanceof InvocationContext) {
-                command.payload[i] = command.payload[i].#currentCommand
+            command.payload[i] = this.#encapsulatePayloadItem(command.payload[i])
+        }
+        return command.appendArgument(this.#currentCommand);
+    }
+
+    #encapsulatePayloadItem = function (payloadItem) {
+        if (typeof (payloadItem) === 'InvocationContext' || payloadItem instanceof InvocationContext) {
+            return new Command(this.runtimeName, CommandType.Value, [payloadItem.#currentCommand])
+        } else if (payloadItem instanceof Array) {
+            for (let i = 0; i < payloadItem.length; i++) {
+                payloadItem[i] = this.#encapsulatePayloadItem(payloadItem)
             }
+            return new Command(this.runtimeName, CommandType.Array, [payloadItem])
+        } else {
+            return new Command(this.runtimeName, CommandType.Value, [payloadItem])
         }
-        return this.#currentCommand == null ? command : command.appendArgument(this.#currentCommand);
     }
 }
 
-module.exports = InvocationContext
+module
+    .exports = InvocationContext

package/lib/sdk/internal/RuntimeContext.js

@@ -4,25 +4,25 @@ const CommandType = require("../../utils/CommandType")
 const InvocationContext = require("./InvocationContext")
 const ConnectionType = require("../../utils/ConnectionType");
 const GeneratorHandler = require("../../core/generator/handler/GeneratorHandler");
-const Runtime = require("../../utils/Runtime");
-const {Handler} = require("../../core/handler/Handler");
+const ExceptionThrower = require('../../core/exception/ExceptionThrower')
 const homedir = require('os').homedir();
 
 
 class RuntimeContext {
-    #currentCommand
-    #interpreter
-    #resultValue
     static memoryRuntimeContexts = new Map();
     static networkRuntimeContexts = new Map();
-    generatorHandler = new GeneratorHandler();
+    #currentCommand
+    #interpreter
+    #generatorHandler
 
-    constructor(runtime, connectionType, tcpConnectionData = null) {
-        this.runtime = runtime
+
+    constructor(runtimeName, connectionType, tcpConnectionData = null) {
+        this.runtimeName = runtimeName
         this.connectionType = connectionType
         this.tcpConnectionData = tcpConnectionData
         this.#currentCommand = null
         this.#interpreter = new Interpreter()
+        this.#generatorHandler = new GeneratorHandler();
     }
 
     static getInstance(runtime, connectionType, tcpConnectionData = null) {
@@ -49,45 +49,58 @@ class RuntimeContext {
         }
     }
 
-    execute(immediateCommand) {
-        this.command = this.#interpreter.execute(immediateCommand, this.connectionType, this.tcpConnectionData)
+    execute() {
+        this.command = this.#interpreter.execute(this.#currentCommand, this.connectionType, this.tcpConnectionData)
+        this.#currentCommand = null
+        if (this.command.commandType === CommandType.Exception) {
+            ExceptionThrower.throwException(this.command)
+        }
     }
 
     loadLibrary(...args) {
-        let localCommand = new Command(this.runtime, CommandType.LoadLibrary, args)
-        if (localCommand.runtime === Runtime.Nodejs) {
-            let handler = new Handler()
-            handler.handleCommand(localCommand)
-        } else {
-            this.execute(localCommand)
-        }
+        let localCommand = new Command(this.runtimeName, CommandType.LoadLibrary, args)
+        this.#currentCommand = this.#buildCommand(localCommand)
+        this.execute()
         return this
     }
 
     getType(...args) {
-        let localCommand = new Command(this.runtime, CommandType.GetType, args)
-        return new InvocationContext(this.runtime, this.connectionType, this.tcpConnectionData, this.#buildCommand(localCommand))
+        let localCommand = new Command(this.runtimeName, CommandType.GetType, args)
+        this.#currentCommand = null
+        return new InvocationContext(this.runtimeName, this.connectionType, this.tcpConnectionData, this.#buildCommand(localCommand))
     }
 
     invokeGlobalMethod(...args) {
-        let localCommand = new Command(this.runtime, CommandType.InvokeGlobalMethod, args)
-        return new InvocationContext(this.runtime, this.connectionType, this.tcpConnectionData, this.#buildCommand(localCommand))
+        let localCommand = new Command(this.runtimeName, CommandType.InvokeGlobalMethod, args)
+        this.#currentCommand = null
+        return new InvocationContext(this.runtimeName, this.connectionType, this.tcpConnectionData, this.#buildCommand(localCommand))
     }
 
     generateLibrary(...args) {
-        let cmd = new Command(this.runtime, CommandType.GenerateLib, args)
+        let cmd = new Command(this.runtimeName, CommandType.GenerateLib, args)
         this.execute(cmd);
-        this.generatorHandler.generate(this.command, homedir);
+        this.#generatorHandler.generate(this.command, homedir);
         return this;
     }
 
-    getValue() {
-        this.#resultValue = this.#currentCommand.payload[0]
-        return this.#resultValue;
+
+    #buildCommand = function (command) {
+        for (let i = 0; i < command.payload.length; i++) {
+            command.payload[i] = this.#iterate(command.payload[i])
+        }
+        return command.appendArgument(this.#currentCommand)
     }
 
-    #buildCommand = function(command) {
-        return !this.#currentCommand ? command : command.appendArgument(this.#currentCommand)
+    #iterate = function (payloadItem) {
+        if (payloadItem instanceof Array) {
+            for (let i = 0; i < payloadItem.length; i++) {
+                payloadItem[i] = this.#iterate(payloadItem)
+            }
+            return new Command(this.runtimeName, CommandType.Array, [payloadItem])
+        }
+        else {
+            return new Command(this.runtimeName, CommandType.Value, [payloadItem])
+        }
     }
 }
 

package/lib/sdk/internal/RuntimeFactory.js

@@ -1,4 +1,4 @@
-const Runtime = require("../../utils/Runtime")
+const Runtime = require("../../utils/RuntimeName")
 const RuntimeContext = require("./RuntimeContext")
 
 class RuntimeFactory {

package/lib/utils/Command.js

@@ -1,58 +1,65 @@
 let CommandType = require('./CommandType')
 
 class Command {
-    constructor(runtime, commandType, payload = []) {
-        this.runtime = runtime
-        this.commandId = commandType
+    constructor(runtimeName, commandType, payload = []) {
+        this.runtimeName = runtimeName
+        this.commandType = commandType
         this.payload = payload
     }
 
-    createResponse(...args) {
+    static createResponse(response, runtimeName) {
         return new Command(
-            this.runtime,
-            CommandType.Response,
-            [...args]
+            runtimeName,
+            CommandType.Value,
+            [response]
         )
     }
 
-    createReference(...args) {
+    static createReference(response, runtimeName) {
         return new Command(
-            this.runtime,
+            runtimeName,
             CommandType.Reference,
-            [...args]
+            [response]
         )
     }
 
-    createArrayResponse(...args) {
+    static createArrayResponse(response, runtimeName) {
         return new Command(
-            this.runtime,
+            runtimeName,
             CommandType.Array,
-            [...args]
+            [response]
         )
     }
 
     dropFirstPayloadArg() {
         return new Command(
-            this.runtime,
-            this.commandId,
+            this.runtimeName,
+            this.commandType,
             this.payload.slice(1)
         )
     }
 
     addArgToPayload(arg) {
         return new Command(
-            this.runtime,
-            this.commandId,
+            this.runtimeName,
+            this.commandType,
             this.payload.concat(arg)
         )
     }
-    
-    appendArgument(arg) {
-        return new Command(
-            this.runtime,
-            this.commandId,
-            [arg].concat(this.payload)
-        )
+
+    appendArgument(current_command) {
+        if (current_command == null) {
+            return new Command(
+                this.runtimeName,
+                this.commandType,
+                this.payload)
+        } else {
+            return new Command(
+                this.runtimeName,
+                this.commandType,
+                [current_command].concat(this.payload)
+            )
+        }
     }
 }
 

package/lib/utils/CommandType.js

@@ -1,5 +1,5 @@
 module.exports = {
-    Response: 0,
+    Value: 0,
     LoadLibrary: 1,
     InvokeStaticMethod: 2,
     GetStaticField: 3,
@@ -17,5 +17,9 @@ module.exports = {
     GenerateLib: 15,
     InvokeGlobalMethod: 16,
     DestructReference: 17,
-    Array: 18
+    Array: 18,
+    ArrayGetItem: 19,
+    ArrayGetSize: 20,
+    ArrayGetRank: 21,
+    ArraySetItem: 22
 }

package/lib/utils/ExceptionType.js

@@ -0,0 +1,10 @@
+module.exports = {
+    EXCEPTION: 0,
+    IO_EXCEPTION: 1,
+    FILE_NOT_FOUND_EXCEPTION: 2,
+    RUNTIME_EXCEPTION: 3,
+    ARITHMETIC_EXCEPTION: 4,
+    ILLEGAL_ARGUMENT_EXCEPTION: 5,
+    INDEX_OUT_OF_BOUNDS_EXCEPTION: 6,
+    NULL_POINTER_EXCEPTION: 7
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "javonet-nodejs-sdk",
-  "version": "2.0.5",
+  "version": "2.1.1",
   "description": "Javonet SDK for NodeJS",
   "main": "lib/Javonet.js",
   "keywords": [],

package/Binaries/Nodejs/Linux/X64/core/transmitter/NodejsTransmitterWrapper.js

@@ -1,36 +0,0 @@
-let library;
-
-class NodejsTransmitterWrapper {
-    static initialize() {
-       if (process.platform === "win32")
-           library = require(`${require('path').resolve(__dirname, '../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`)
-        else if (process.platform === "darwin")
-           library = require(`${require('path').resolve(__dirname, '../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`)
-        else
-           library = require(`${require('path').resolve(__dirname, '../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`)
-       let binariesRootPath = String(`${require('path').resolve(__dirname, '../../../')}`)
-       return library.initializeTransmitter(binariesRootPath)
-    }
-
-    static activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword) {
-        this.initialize()
-        return library.activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword)
-    }
-
-    static sendCommand(messageArray) {
-        if (library) {
-            let result = library.sendCommand(messageArray)
-            if (Array.isArray(result)) {
-                return result
-            }
-            else {
-                throw new Error("Javonet native code error: " + result)
-            }
-        }
-        else {
-            throw new Error("Javonet not active")
-        }
-    }
-}
-
-module.exports = NodejsTransmitterWrapper

package/Binaries/Nodejs/MacOs/X64/core/transmitter/NodejsTransmitterWrapper.js

@@ -1,36 +0,0 @@
-let library;
-
-class NodejsTransmitterWrapper {
-    static initialize() {
-       if (process.platform === "win32")
-           library = require(`${require('path').resolve(__dirname, '../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`)
-        else if (process.platform === "darwin")
-           library = require(`${require('path').resolve(__dirname, '../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`)
-        else
-           library = require(`${require('path').resolve(__dirname, '../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`)
-       let binariesRootPath = String(`${require('path').resolve(__dirname, '../../../')}`)
-       return library.initializeTransmitter(binariesRootPath)
-    }
-
-    static activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword) {
-        this.initialize()
-        return library.activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword)
-    }
-
-    static sendCommand(messageArray) {
-        if (library) {
-            let result = library.sendCommand(messageArray)
-            if (Array.isArray(result)) {
-                return result
-            }
-            else {
-                throw new Error("Javonet native code error: " + result)
-            }
-        }
-        else {
-            throw new Error("Javonet not active")
-        }
-    }
-}
-
-module.exports = NodejsTransmitterWrapper