javonet-ruby-sdk 2.4.10 → 2.4.11

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/handler/Handler.js

@@ -1,90 +0,0 @@
-const CommandType = require('../../utils/CommandType')
-const Command = require("../../utils/Command");
-const ReferenceCache = require('../referenceCache/ReferencesCache')
-const ExceptionSerializer = require('../../utils/exception/ExceptionSerializer')
-
-const ValueHandler = require('./ValueHandler')
-const LoadLibraryHandler = require('./LoadLibraryHandler')
-const GetTypeHandler = require('./GetTypeHandler')
-const InvokeStaticMethodHandler = require('./InvokeStaticMethodHandler')
-const GetStaticFieldHandler = require('./GetStaticFieldHandler')
-const SetStaticFieldHandler = require('./SetStaticFieldHandler')
-const ResolveReferenceHandler = require('./ResolveReferenceHandler')
-const CreateClassInstanceHandler = require('./CreateClassInstanceHandler')
-const GetInstanceFieldHandler = require('./GetInstanceFieldHandler')
-const SetInstanceFieldHandler = require('./SetInstanceFieldHandler')
-const InvokeInstanceMethodHandler = require('./InvokeInstanceMethodHandler')
-const DestructReferenceHandler = require("./DestructReferenceHandler");
-const CastHandler = require('./CastingHandler')
-const InvokeGlobalMethodHandler = require('./InvokeGlobalMethodHandler')
-const ArrayGetItemHandler = require('./ArrayGetItemHandler')
-const ArrayGetSizeHandler = require('./ArrayGetSizeHandler')
-const ArrayGetRankHandler = require('./ArrayGetRankHandler')
-const ArraySetItemHandler = require('./ArraySetItemHandler')
-const ArrayHandler = require('./ArrayHandler')
-const EnableNamespaceHandler = require('./EnableNamespaceHandler')
-const EnableTypeHandler = require('./EnableTypeHandler')
-
-
-function isResponseSimpleType(response) {
-    let type = typeof (response)
-    return ['string', 'boolean', 'number'].includes(type)
-}
-
-function isResponseNull(response) {
-    return response === null
-}
-
-
-const handlers = {
-    [CommandType.Value]: ValueHandler,
-    [CommandType.LoadLibrary]: LoadLibraryHandler,
-    [CommandType.InvokeStaticMethod]: InvokeStaticMethodHandler,
-    [CommandType.GetType]: GetTypeHandler,
-    [CommandType.GetStaticField]: GetStaticFieldHandler,
-    [CommandType.SetStaticField]: SetStaticFieldHandler,
-    [CommandType.CreateClassInstance]: CreateClassInstanceHandler,
-    [CommandType.Reference]: ResolveReferenceHandler,
-    [CommandType.Cast]: CastHandler,
-    [CommandType.GetInstanceField]: GetInstanceFieldHandler,
-    [CommandType.SetInstanceField]: SetInstanceFieldHandler,
-    [CommandType.InvokeInstanceMethod]: InvokeInstanceMethodHandler,
-    [CommandType.InvokeGlobalMethod]: InvokeGlobalMethodHandler,
-    [CommandType.DestructReference]: DestructReferenceHandler,
-    [CommandType.ArrayGetItem]: ArrayGetItemHandler,
-    [CommandType.ArrayGetSize]: ArrayGetSizeHandler,
-    [CommandType.ArrayGetRank]: ArrayGetRankHandler,
-    [CommandType.ArraySetItem]: ArraySetItemHandler,
-    [CommandType.Array]: ArrayHandler,
-    [CommandType.EnableNamespace]: EnableNamespaceHandler,
-    [CommandType.EnableType]: EnableTypeHandler
-}
-
-class Handler {
-    handleCommand(command) {
-        try {
-            if (command.commandType === CommandType.RetrieveArray) {
-                let responseArray = handlers[CommandType.Reference].handleCommand(command.payload[0])
-                return Command.createArrayResponse(responseArray, command.runtimeName)
-            }
-            let response = handlers[command.commandType].handleCommand(command)
-            return this.parseCommand(response, command.runtimeName)
-        } catch (error) {
-            return ExceptionSerializer.serializeException(error, command)
-        }
-    }
-
-    parseCommand(response, runtimeName) {
-        if (isResponseNull(response) || isResponseSimpleType(response)) {
-            return Command.createResponse(response, runtimeName)
-        } else {
-            let cache = ReferenceCache.getInstance()
-            let uuid = cache.cacheReference(response)
-            return Command.createReference(uuid, runtimeName)
-        }
-    }
-}
-
-module.exports.Handler = Handler
-module.exports.handlers = handlers
-

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/handler/InvokeGlobalMethodHandler.js

@@ -1,47 +0,0 @@
-const AbstractHandler = require("./AbstractHandler");
-
-class InvokeGlobalMethodHandler extends AbstractHandler {
-  requiredParametersCount = 1;
-
-  constructor() {
-    super();
-  }
-
-  process(command) {
-    try {
-      if (command.payload.length < this.requiredParametersCount) {
-        throw new Error("Invoke Global Method parameters mismatch");
-      }
-      const { payload } = command;
-      const splitted = payload[0].split(".");
-      let methodToInvoke;
-      for (let i = 0; i < splitted.length; i++) {
-        methodToInvoke = !methodToInvoke
-          ? global[splitted[i]]
-          : methodToInvoke[splitted[i]];
-      }
-      if (typeof methodToInvoke === "undefined") {
-        let methods = Object.getOwnPropertyNames(global).filter(function (
-          property
-        ) {
-          return typeof global[property] === "function";
-        });
-        let message = `Method ${payload[0]} not found in global. Available methods:\n`;
-        methods.forEach((methodIter) => {
-          message += `${methodIter}\n`;
-        });
-        throw new Error(message);
-      }
-      if (payload.length > 1) {
-        const args = payload.slice(1);
-        return methodToInvoke(args);
-      } else {
-        return methodToInvoke();
-      }
-    } catch (error) {
-      throw this.process_stack_trace(error, this.constructor.name);
-    }
-  }
-}
-
-module.exports = new InvokeGlobalMethodHandler();

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/handler/InvokeInstanceMethodHandler.js

@@ -1,40 +0,0 @@
-const AbstractHandler = require("./AbstractHandler");
-
-class InvokeInstanceMethodHandler extends AbstractHandler {
-  requiredParametersCount = 2;
-
-  constructor() {
-    super();
-  }
-
-  process(command) {
-    try {
-      if (command.payload.length < this.requiredParametersCount) {
-        throw new Error("Invoke Instance Method parameters mismatch");
-      }
-      const { payload } = command;
-      let instance = payload[0];
-      let methodName = payload[1];
-      let args = payload.slice(2);
-      let method = instance[methodName];
-      if (typeof method === "undefined") {
-        let methods = Object.getOwnPropertyNames(instance.__proto__).filter(
-          function (property) {
-            return typeof instance.__proto__[property] === "function";
-          }
-        );
-        let message = `Method ${methodName} not found in object. Available methods:\n`;
-        methods.forEach((methodIter) => {
-          message += `${methodIter}\n`;
-        });
-        throw new Error(message);
-      } else {
-        return Reflect.apply(method, instance, args);
-      }
-    } catch (error) {
-      throw this.process_stack_trace(error, this.constructor.name);
-    }
-  }
-}
-
-module.exports = new InvokeInstanceMethodHandler();

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/handler/InvokeStaticMethodHandler.js

@@ -1,40 +0,0 @@
-const AbstractHandler = require("./AbstractHandler");
-
-class InvokeStaticMethodHandler extends AbstractHandler {
-  requiredParametersCount = 2;
-
-  constructor() {
-    super();
-  }
-
-  process(command) {
-    try {
-      if (command.payload.length < this.requiredParametersCount) {
-        throw new Error("Invoke Static Method parameters mismatch");
-      }
-      const { payload } = command;
-      let type = payload[0];
-      let methodName = payload[1];
-      let args = payload.slice(2);
-      let method = type[methodName];
-      if (typeof method === "undefined") {
-        let methods = Object.getOwnPropertyNames(type).filter(function (
-          property
-        ) {
-          return typeof type[property] === "function";
-        });
-        let message = `Method ${methodName} not found in class. Available methods:\n`;
-        methods.forEach((methodIter) => {
-          message += `${methodIter}\n`;
-        });
-        throw new Error(message);
-      } else {
-        return Reflect.apply(method, undefined, args);
-      }
-    } catch (error) {
-      throw this.process_stack_trace(error, this.constructor.name);
-    }
-  }
-}
-
-module.exports = new InvokeStaticMethodHandler();

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/handler/LoadLibraryHandler.js

@@ -1,41 +0,0 @@
-const AbstractHandler = require('./AbstractHandler')
-
-class LoadLibraryHandler extends AbstractHandler {
-    requiredParametersCount = 1
-
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        if (command.payload.length < this.requiredParametersCount) {
-            throw new Error("Load Library parameters mismatch")
-        }
-        let {payload} = command
-        let [lib] = payload
-        let pathArray = lib.split(/[/\\]/)
-        let libraryName = pathArray.length > 1 ? pathArray[pathArray.length - 1] : pathArray[0]
-        libraryName = libraryName.replace('.js', '')
-
-        let moduleExports
-
-        try {
-            moduleExports = require(lib)
-        } catch (error) {
-            try {
-                moduleExports = require(`${process.cwd()}/${lib}`)
-            } catch (error) {
-                throw this.process_stack_trace(error, this.constructor.name)
-            }
-        }
-        global[libraryName] = moduleExports
-
-        for (const [key, value] of Object.entries(moduleExports)) {
-            // Here, `key` is the name of the export, and `value` is the exported type itself.
-            global[key] = value
-        }
-        return 0
-    }
-}
-
-module.exports = new LoadLibraryHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/handler/ResolveReferenceHandler.js

@@ -1,14 +0,0 @@
-const AbstractHandler = require("./AbstractHandler");
-const ReferenceCache = require("../referenceCache/ReferencesCache")
-
-class ResolveReferenceHandler extends AbstractHandler {
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        return ReferenceCache.getInstance().resolveReference(command.payload[0])
-    }
-}
-
-module.exports = new ResolveReferenceHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/handler/SetGlobalStaticFieldHandler.js

@@ -1,44 +0,0 @@
-const AbstractHandler = require("./AbstractHandler");
-
-class SetGlobalStaticFieldHandler extends AbstractHandler {
-  requiredParametersCount = 2;
-
-  constructor() {
-    super();
-  }
-
-  process(command) {
-    try {
-      if (command.payload.length < this.requiredParametersCount) {
-        throw new Error("Set gloabal static field parameters mismatch");
-      }
-      const { payload } = command;
-      const splitted = payload[0].split(".");
-      const value = payload[1];
-      let fieldToSet;
-
-      for (let i = 0; i < splitted.length; i++) {
-        if (
-          typeof (fieldToSet
-            ? fieldToSet[splitted[i]]
-            : global[splitted[i]]) === "undefined"
-        ) {
-          let fields = Object.keys(fieldToSet ? fieldToSet : global);
-          let message = `Field ${splitted[i]} not found in object. Available fields:\n`;
-          fields.forEach((fieldIter) => {
-            message += `${fieldIter}\n`;
-          });
-          throw new Error(message);
-        }
-        fieldToSet = !fieldToSet
-          ? global[splitted[i]]
-          : fieldToSet[splitted[i]];
-      }
-      fieldToSet = value;
-    } catch (error) {
-      throw this.process_stack_trace(error, this.constructor.name);
-    }
-  }
-}
-
-module.exports = new SetGlobalStaticFieldHandler();

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/handler/SetInstanceFieldHandler.js

@@ -1,35 +0,0 @@
-const AbstractHandler = require("./AbstractHandler");
-
-class SetInstanceFieldHandler extends AbstractHandler {
-  requiredParametersCount = 3;
-
-  constructor() {
-    super();
-  }
-
-  process(command) {
-    try {
-      if (command.payload.length < this.requiredParametersCount) {
-        throw new Error("Set Instance Field parameters mismatch");
-      }
-      const { payload } = command;
-      let instance = payload[0];
-      let field = payload[1];
-      let value = payload[2];
-      if (typeof instance[field] === "undefined") {
-        let fields = Object.keys(instance);
-        let message = `Field ${field} not found in object. Available fields:\n`;
-        fields.forEach((fieldIter) => {
-          message += `${fieldIter}\n`;
-        });
-        throw new Error(message);
-      }
-      instance[field] = value;
-      return 0;
-    } catch (error) {
-      throw this.process_stack_trace(error, this.constructor.name);
-    }
-  }
-}
-
-module.exports = new SetInstanceFieldHandler();

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/handler/SetStaticFieldHandler.js

@@ -1,33 +0,0 @@
-const AbstractHandler = require("./AbstractHandler");
-
-class SetStaticFieldHandler extends AbstractHandler {
-  requiredParametersCount = 3;
-
-  constructor() {
-    super();
-  }
-
-  process(command) {
-    try {
-      if (command.payload.length < this.requiredParametersCount) {
-        throw new Error("Set static field parameters mismatch");
-      }
-      const { payload } = command;
-      let [obj, field, value] = payload;
-      if (typeof obj[field] === "undefined") {
-        let fields = Object.keys(obj);
-        let message = `Field ${field} not found in class ${obj.constructor.name}. Available fields:\n`;
-        fields.forEach((fieldIter) => {
-          message += `${fieldIter}\n`;
-        });
-        throw new Error(message);
-      }
-      obj[field] = value;
-      return 0;
-    } catch (error) {
-      throw this.process_stack_trace(error, this.constructor.name);
-    }
-  }
-}
-
-module.exports = new SetStaticFieldHandler();

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/handler/ValueHandler.js

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

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/interpreter/Interpreter.js

@@ -1,46 +0,0 @@
-const { Handler } = require('../handler/Handler')
-const CommandSerializer = require('../protocol/CommandSerializer')
-const CommandDeserializer = require('../protocol/CommandDeserializer')
-const Runtime = require("../../utils/RuntimeName");
-const ConnectionType = require('../../utils/ConnectionType');
-
-let Transmitter
-let Receiver
-
-class Interpreter {
-    handler = new Handler()
-
-    execute(command, connectionType, tcpAddress) {
-        let commandSerializer = new CommandSerializer()
-        let byteMessage = commandSerializer.serialize(command,connectionType, tcpAddress)
-        let responseByteArray
-
-        if (command.runtimeName === Runtime.Nodejs && connectionType === ConnectionType.IN_MEMORY)
-        {
-            // lazy receiver loading
-            if (!Receiver) {
-                Receiver = require('../receiver/Receiver')
-            }
-            responseByteArray = Receiver.sendCommand(byteMessage)
-
-        }
-        else {
-            // lazy transmitter loading
-            if (!Transmitter) {
-                Transmitter = require('../transmitter/Transmitter')
-            }
-            responseByteArray = Transmitter.sendCommand(byteMessage)
-        }
-        return new CommandDeserializer(responseByteArray).deserialize()
-    }
-
-    process(byteArray) {
-        let commandDeserializer = new CommandDeserializer(byteArray)
-        let receivedCommand = commandDeserializer.deserialize()
-        let responseCommand = this.handler.handleCommand(receivedCommand)
-        let commandSerializer = new CommandSerializer()
-        return commandSerializer.serialize(responseCommand, ConnectionType.IN_MEMORY)
-    }
-}
-
-module.exports = Interpreter

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/namespaceCache/NamespaceCache.js

@@ -1,39 +0,0 @@
-class NamespaceCache {
-    static _instance = null;
-    namespaceCache = [];
-
-    constructor() {
-        if (NamespaceCache._instance === null) {
-            NamespaceCache._instance = this;
-        }
-        return NamespaceCache._instance;
-    }
-
-    cacheNamespace(namespaceRegex) {
-        this.namespaceCache.push(namespaceRegex);
-    }
-
-    isNamespaceCacheEmpty() {
-        return this.namespaceCache.length === 0;
-    }
-
-    isTypeAllowed(typeToCheck) {
-        for (let pattern of this.namespaceCache) {
-            if (new RegExp(pattern).test(typeToCheck.constructor.name)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    getCachedNamespaces() {
-        return this.namespaceCache;
-    }
-
-    clearCache() {
-        this.namespaceCache = [];
-        return 0;
-    }
-}
-
-module.exports = NamespaceCache;

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

@@ -1,170 +0,0 @@
-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()
-            case 'JAVONET_NULL':
-                return this.readNull()
-            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))
-    }
-
-    readNull() {
-        let size = 1
-        this.position += 2
-        let p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeNull()
-    }
-}
-
-module.exports = CommandDeserializer