javonet-ruby-sdk 2.4.10 → 2.4.11

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/CommandType.py

@@ -1,41 +0,0 @@
-from enum import Enum
-
-
-class CommandType(Enum):
-    Value = 0
-    LoadLibrary = 1
-    InvokeStaticMethod = 2
-    GetStaticField = 3
-    SetStaticField = 4
-    CreateClassInstance = 5
-    GetType = 6
-    Reference = 7
-    GetModule = 8
-    InvokeInstanceMethod = 9
-    Exception = 10
-    HeartBeat = 11
-    Cast = 12
-    GetInstanceField = 13
-    Optimize = 14
-    GenerateLib = 15
-    InvokeGlobalMethod = 16
-    DestructReference = 17
-    ArrayReference = 18
-    ArrayGetItem = 19
-    ArrayGetSize = 20
-    ArrayGetRank = 21
-    ArraySetItem = 22
-    Array = 23
-    RetrieveArray = 24
-    SetInstanceField = 25
-    InvokeGenericStaticMethod = 26
-    InvokeGenericMethod = 27
-    GetEnumItem = 28
-    GetEnumName = 29
-    GetEnumValue = 30
-    AsRef = 31
-    AsOut = 32
-    GetRefValue = 33
-    EnableNamespace = 34
-    EnableType = 35
-    CreateNull = 36

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/ConnectionType.py

@@ -1,7 +0,0 @@
-from enum import Enum
-
-
-class ConnectionType(Enum):
-    InMemory = 0
-    Tcp = 1
-    WebSocket = 2

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/ExceptionType.py

@@ -1,55 +0,0 @@
-from enum import Enum
-
-
-class ExceptionType(Enum):
-    Exception = 0
-    IOException = 1
-    FileNotFoundException = 2
-    RuntimeException = 3
-    ArithemticException = 4
-    IllegalArgumentException = 5
-    IndexOutOfBoundsException = 6
-    NullPointerException = 7
-    ZeroDivisionException = 8
-
-    @staticmethod
-    def to_enum(exception_name):
-        if exception_name == "Exception":
-            return ExceptionType.Exception.value
-        if exception_name == "IOError":
-            return ExceptionType.IOException.value
-        if exception_name == "FileNotFoundError":
-            return ExceptionType.FileNotFoundException.value
-        if exception_name == "RuntimeError":
-            return ExceptionType.RuntimeException.value
-        if exception_name == "ArithmeticError":
-            return ExceptionType.ArithemticException.value
-        if exception_name == "IndexError":
-            return ExceptionType.IndexOutOfBoundsException.value
-        if exception_name == "AttributeError":
-            return ExceptionType.NullPointerException.value
-        if exception_name == "ZeroDivisionError":
-            return ExceptionType.ZeroDivisionException.value
-        else:
-            return ExceptionType.Exception.value
-
-    @staticmethod
-    def to_exception(exception_enum):
-        if exception_enum == ExceptionType.Exception.value:
-            return Exception
-        if exception_enum == ExceptionType.IOException.value:
-            return IOError
-        if exception_enum == ExceptionType.FileNotFoundException.value:
-            return FileNotFoundError
-        if exception_enum == ExceptionType.RuntimeException.value:
-            return RuntimeError
-        if exception_enum == ExceptionType.ArithemticException.value:
-            return ArithmeticError
-        if exception_enum == ExceptionType.IndexOutOfBoundsException.value:
-            return IndexError
-        if exception_enum == ExceptionType.NullPointerException.value:
-            return AttributeError
-        if exception_enum == ExceptionType.ZeroDivisionException.value:
-            return ZeroDivisionError
-        else:
-            return Exception

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/RuntimeName.py

@@ -1,13 +0,0 @@
-from enum import Enum
-
-
-class RuntimeName(Enum):
-    clr = 0
-    go = 1
-    jvm = 2
-    netcore = 3
-    perl = 4
-    python = 5
-    ruby = 6
-    nodejs = 7
-    cpp = 8

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/RuntimeNameHandler.py

@@ -1,26 +0,0 @@
-from javonet.utils.RuntimeName import RuntimeName
-
-
-class RuntimeNameHandler:
-
-    @staticmethod
-    def get_name(runtime_name):
-        if isinstance(runtime_name, RuntimeName):
-            if runtime_name == RuntimeName.clr:
-                return "clr"
-            elif runtime_name == RuntimeName.go:
-                return "go"
-            elif runtime_name == RuntimeName.jvm:
-                return "jvm"
-            elif runtime_name == RuntimeName.netcore:
-                return "netcore"
-            elif runtime_name == RuntimeName.perl:
-                return "perl"
-            elif runtime_name == RuntimeName.python:
-                return "python"
-            elif runtime_name == RuntimeName.ruby:
-                return "ruby"
-            elif runtime_name == RuntimeName.nodejs:
-                return "nodejs"
-        else:
-            raise Exception("Invalid runtime name.")

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/StringEncodingMode.py

@@ -1,8 +0,0 @@
-from enum import Enum
-
-
-class StringEncodingMode(Enum):
-    ASCII = 0
-    UTF8 = 1
-    UTF16 = 2
-    UTF32 = 3

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/Type.py

@@ -1,16 +0,0 @@
-from enum import Enum
-
-
-class Type(Enum):
-    Command = 0
-    JavonetString = 1
-    JavonetInteger = 2
-    JavonetBoolean = 3
-    JavonetFloat = 4
-    JavonetByte = 5
-    JavonetChar = 6
-    JavonetLongLong = 7
-    JavonetDouble = 8
-    JavonetUnsignedLongLong = 9
-    JavonetUnsignedInteger = 10
-    JavonetNoneType = 11

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/connectionData/IConnectionData.py

@@ -1,18 +0,0 @@
-from abc import ABC, abstractmethod
-from javonet.utils.ConnectionType import ConnectionType
-
-
-class IConnectionData(ABC):
-    @property
-    @abstractmethod
-    def connection_type(self):
-        pass
-
-    @property
-    @abstractmethod
-    def hostname(self):
-        pass
-
-    @abstractmethod
-    def serialize_connection_data(self):
-        pass

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/connectionData/InMemoryConnectionData.py

@@ -1,23 +0,0 @@
-from javonet.utils.ConnectionType import ConnectionType
-from javonet.utils.connectionData.IConnectionData import IConnectionData
-
-
-class InMemoryConnectionData(IConnectionData):
-    @property
-    def connection_type(self):
-        return ConnectionType.InMemory
-
-    @property
-    def hostname(self):
-        return ""
-
-    def serialize_connection_data(self):
-        return [self.connection_type.value, 0, 0, 0, 0, 0, 0]
-
-    def __eq__(self, other):
-        return isinstance(other, InMemoryConnectionData)
-
-    def __hash__(self):
-        hash_code = 593727026
-        hash_code = hash_code * -1521134295 + hash(self.connection_type)
-        return hash_code

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/connectionData/TcpConnectionData.py

@@ -1,67 +0,0 @@
-import hashlib
-import socket
-
-from javonet.utils.ConnectionType import ConnectionType
-from javonet.utils.connectionData.IConnectionData import IConnectionData
-
-
-class TcpConnectionData(IConnectionData):
-
-    def __init__(self, hostname: str, port: int):
-        self._hostname = hostname
-        self._port = port
-        self._ip_address = ""
-        if self._hostname == "localhost":
-            self._ip_address = "127.0.0.1"
-        else:
-            try:
-                self._ip_address = socket.gethostbyname(self._hostname)
-            except socket.gaierror:
-                self._ip_address = ""
-
-    @property
-    def connection_type(self):
-        return ConnectionType.Tcp
-
-    @property
-    def hostname(self):
-        return self._hostname
-
-    @property
-    def ip_address(self):
-        return self._ip_address
-
-    @property
-    def port(self):
-        return self._port
-
-    def serialize_connection_data(self):
-        address_bytes = self.__get_address_bytes()
-        port_bytes = self.__get_pot_bytes()
-        return [self.connection_type.value] + address_bytes + port_bytes
-
-    def __get_address_bytes(self):
-        return [int(x) for x in self._ip_address.split(".")]
-
-    def __get_pot_bytes(self):
-        return [self._port & 0xFF, self._port >> 8]
-
-    def __eq__(self, other):
-        if isinstance(other, TcpConnectionData):
-            return self._ip_address == other.ip_address and self._port == other.port
-        return False
-
-    def __hash__(self):
-        return int(hashlib.sha1(f"{self._ip_address}{self._port}".encode()).hexdigest(), 16)
-
-    @hostname.setter
-    def hostname(self, value):
-        self._hostname = value
-
-    @port.setter
-    def port(self, value):
-        self._port = value
-
-    @ip_address.setter
-    def ip_address(self, value):
-        self._ip_address = value

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/connectionData/WsConnectionData.py

@@ -1,30 +0,0 @@
-import hashlib
-
-from javonet.utils.ConnectionType import ConnectionType
-from javonet.utils.connectionData.IConnectionData import IConnectionData
-
-
-class WsConnectionData(IConnectionData):
-
-    def __init__(self, hostname: str):
-        self._hostname = hostname
-    @property
-    def connection_type(self):
-        return ConnectionType.WebSocket
-
-    @property
-    def hostname(self):
-        return self._hostname
-
-    def serialize_connection_data(self):
-        return [self.connection_type.value, 0, 0, 0, 0, 0, 0]
-
-    def __eq__(self, other):
-        return isinstance(other, WsConnectionData) and self._hostname == other.hostname
-
-    def __hash__(self):
-        return int(hashlib.sha1(f"{self.hostname}".encode()).hexdigest(), 16)
-
-    @hostname.setter
-    def hostname(self, value):
-        self._hostname = value

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/exception/ExceptionSerializer.py

@@ -1,60 +0,0 @@
-import os
-import traceback
-
-from javonet.core.generator.internal.PythonStringBuilder import PythonStringBuilder
-from javonet.utils.ExceptionType import ExceptionType
-
-from javonet.utils.Command import Command
-from javonet.utils.CommandType import CommandType
-
-
-class ExceptionSerializer:
-
-    @staticmethod
-    def serialize_exception(exception, command):
-        exception_command = Command(command.runtime_name, CommandType.Exception, [])
-        tb = exception.__traceback__
-        trace = traceback.extract_tb(tb)
-        exception_message = str(exception)
-        exception_name = exception.__cause__.__class__.__name__
-        stack_classes = PythonStringBuilder()
-        stack_methods = PythonStringBuilder()
-        stack_lines = PythonStringBuilder()
-        stack_files = PythonStringBuilder()
-
-        is_debug = False
-
-        for frame_summary in trace:
-            if "javonet" not in frame_summary.filename or is_debug:
-                stack_classes.append(ExceptionSerializer.format_class_name_from_file(frame_summary.filename)).append("|")
-                stack_methods.append(frame_summary.name).append("|")
-                stack_lines.append(str(frame_summary.lineno)).append("|")
-                stack_files.append(frame_summary.filename).append("|")
-
-        exception_command = exception_command.add_arg_to_payload(ExceptionSerializer.get_exception_code(exception_name))
-        exception_command = exception_command.add_arg_to_payload(str(command))
-        exception_command = exception_command.add_arg_to_payload(exception_name)
-        exception_command = exception_command.add_arg_to_payload(str(exception_message))
-        exception_command = exception_command.add_arg_to_payload(stack_classes.__str__())
-        exception_command = exception_command.add_arg_to_payload(stack_methods.__str__())
-        exception_command = exception_command.add_arg_to_payload(stack_lines.__str__())
-        exception_command = exception_command.add_arg_to_payload(stack_files.__str__())
-
-        return exception_command
-
-    @staticmethod
-    def get_exception_code(exception_name):
-        return ExceptionType.to_enum(exception_name)
-
-    Exception = 0
-    IOException = 1
-    FileNotFoundException = 2
-    RuntimeException = 3
-    ArithmeticException = 4
-    IllegalArgumentException = 5
-    IndexOutOfBoundsException = 6
-    NullPointerException = 7
-
-    @staticmethod
-    def format_class_name_from_file(filename):
-        return os.path.splitext((os.path.split(filename)[1]))[0]

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/exception/ExceptionThrower.py

@@ -1,77 +0,0 @@
-import re
-
-from javonet.utils.exception.JavonetException import JavonetException
-from javonet.utils.Command import Command
-from javonet.utils.ExceptionType import ExceptionType
-
-
-class ExceptionThrower:
-
-    @staticmethod
-    def throw_exception(command_exception: Command):
-        stack_classes, stack_methods, stack_lines, stack_files = "", "", "", ""
-        exception_message = "Python Exception with empty message"
-        exception_name = "Python exception"
-        javonet_stack_command = ""
-        traceback_str = ""
-
-        exception_payload_len = len(command_exception.payload)
-        if exception_payload_len >=8:
-            stack_classes, stack_methods, stack_lines, stack_files = ExceptionThrower.get_local_stack_trace(
-                command_exception.get_payload()[4],
-                command_exception.get_payload()[5],
-                command_exception.get_payload()[6],
-                command_exception.get_payload()[7])
-
-        if exception_payload_len >= 4:
-            exception_message = command_exception.get_payload()[3]
-
-        if exception_payload_len >= 3:
-            exception_name = command_exception.get_payload()[2]
-
-        if exception_payload_len >= 2:
-            javonet_stack_command = command_exception.get_payload()[1]
-
-        if exception_payload_len >= 1:
-            original_exception = ExceptionType.to_exception(command_exception.get_payload()[0])
-
-
-        for i in range(len(stack_classes)):
-            if i < len(stack_files) and stack_files[i]:
-                traceback_str += "File \"{}\"".format(stack_files[i])
-            if i < len(stack_lines) and stack_lines[i]:
-                traceback_str += ", line {}".format(stack_lines[i])
-            if i < len(stack_methods) and stack_methods[i]:
-                traceback_str += ", in {}".format(stack_methods[i])
-            traceback_str += "\n"
-            if i < len(stack_classes) and stack_classes[i]:
-                traceback_str += "    {}\n".format(stack_classes[i])
-
-        return ExceptionThrower.raise_exception(original_exception, exception_message, traceback_str)
-
-    @staticmethod
-    def raise_exception(original_exception, exception_message, traceback_str):
-        return JavonetException(str(original_exception), exception_message, traceback_str)
-
-    @staticmethod
-    def get_local_stack_trace(stack_trace_classes, stack_trace_methods, stack_trace_lines, stack_trace_files):
-        try:
-            stack_classes = re.split("\\|", stack_trace_classes)
-        except Exception:
-            stack_classes = ""
-
-        try:
-            stack_methods = re.split("\\|", stack_trace_methods)
-        except Exception:
-            stack_methods = ""
-
-        try:
-            stack_lines = re.split("\\|", stack_trace_lines)
-        except Exception:
-            stack_lines = ""
-
-        try:
-            stack_files = re.split("\\|", stack_trace_files)
-        except Exception:
-            stack_files = ""
-        return [stack_classes, stack_methods, stack_lines, stack_files]

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/exception/JavonetException.py

@@ -1,10 +0,0 @@
-class JavonetException(Exception):
-    def __init__(self, name, message, traceback_str):
-        self.name = name
-        self.message = message
-        self.traceback_str = traceback_str
-
-    def __str__(self):
-        return f"{self.name}: {self.message}\n{self.traceback_str}"
-
-

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/callback/callbackFunc.py

@@ -1,5 +0,0 @@
-def callbackFunc(message_byte_array, message_byte_array_len):
-    from javonet.core.receiver.Receiver import Receiver
-    python_receiver = Receiver()
-    response = python_receiver.HeartBeat(message_byte_array, message_byte_array_len)
-    return response

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/generator/handler/AbstractGeneretatorHandler.py

@@ -1,8 +0,0 @@
-
-class AbstractGeneratorHandler:
-
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        raise NotImplementedError('subclasses must override generate_command()!')
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        raise NotImplementedError('subclasses must override generate_command()!')

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/generator/handler/CreateInstanceGeneratorHandler.py

@@ -1,44 +0,0 @@
-import inspect
-
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.core.generator.internal.CommonGenerator import CommonGenerator
-from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-from javonet.utils.Command import Command
-from javonet.utils.CommandType import CommandType
-from javonet.utils.RuntimeName import RuntimeName
-
-
-class CreateInstanceGeneratorHandler(AbstractGeneratorHandler):
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        create_instance_command = Command(RuntimeName.python, CommandType.CreateClassInstance, [])
-        create_instance_command = create_instance_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.CLASS_NAME].generate_command(parent_command.get_payload()[0],
-                                                                                   create_instance_command, handlers))
-        create_instance_command = create_instance_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_command(analyzed_object.__name__,
-                                                                                 create_instance_command, handlers))
-        parameter_types = []
-        parameter_names = list(inspect.getfullargspec(analyzed_object)[0])
-        parameters_dict = inspect.getfullargspec(analyzed_object)[6]
-        for parameter_name in parameter_names:
-            parameter_types.append(handlers.SHARED_HANDLER[SharedHandlerType.TYPE].generate_command(
-                str(parameters_dict.get(parameter_name, "")),
-                create_instance_command,
-                handlers))
-
-        create_instance_command = create_instance_command.add_arg_to_payload(parameter_types[1:])
-        create_instance_command = create_instance_command.add_arg_to_payload(parameter_names[1:])
-        return create_instance_command
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-
-        existing_string_builder.append("    def __init__(self")
-        if len(used_object.get_payload()[3]) > 0:
-            existing_string_builder.append(", ")
-        CommonGenerator.process_method_arguments(existing_string_builder, common_command, used_object.get_payload()[2],
-                                                 used_object.get_payload()[3], handlers)
-        existing_string_builder.append("):")
-        handlers.SHARED_HANDLER[SharedHandlerType.METHOD_BODY].generate_code(existing_string_builder, common_command,
-                                                                             used_object, handlers)
-
-        existing_string_builder.append("\n")

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/generator/handler/GeneratorHandler.py

@@ -1,65 +0,0 @@
-import importlib
-import importlib.util
-import inspect
-import os
-from os import listdir
-from os.path import isfile, join
-
-from javonet.core.generator.handler.Handlers import Handlers
-from javonet.core.generator.internal.PythonStringBuilder import PythonStringBuilder
-from javonet.utils.Command import Command
-from javonet.utils.CommandType import CommandType
-from javonet.utils.RuntimeName import RuntimeName
-
-
-class GeneratorHandler:
-
-    def analyze(self, package_path):
-        handlers = Handlers()
-        handlers.types_to_analyze.extend(self.return_classes_from_package(package_path))
-        structured_command_for_class = Command(RuntimeName.python, CommandType.GenerateLib, [])
-
-        while len(handlers.types_to_analyze) > 0:
-            structured_command_for_class = structured_command_for_class. \
-                add_arg_to_payload(handlers.GENERATOR_HANDLER[CommandType.GetType].
-                                   generate_command(handlers.types_to_analyze.pop(0), structured_command_for_class,
-                                                    handlers))
-
-        return structured_command_for_class
-
-    def generate(self, command, file_path):
-        generator_handlers = Handlers()
-        for i in range(0, len(command.get_payload())):
-            existing_string_builder = PythonStringBuilder()
-            if isinstance(command.get_payload()[i], Command):
-                generator_handlers.GENERATOR_HANDLER[command.get_payload()[i].command_type].generate_code(
-                    existing_string_builder, command, command.get_payload()[i], generator_handlers)
-                self.generate_class_file(existing_string_builder, str(command.get_payload()[i].get_payload()[0]),
-                                         file_path)
-            else:
-                raise Exception(
-                    "GeneratorHandlerException: Argument is not type of PythonCommand GetTypeCommand: " + str(
-                        command.getPayload()[i]))
-
-    def generate_class_file(self, existing_string_builder, class_file_name, file_path):
-        if not os.path.exists(file_path):
-            os.makedirs(file_path)
-        f = open(os.path.join(file_path, class_file_name) + ".py", "w+")
-        f.write(str(existing_string_builder))
-        f.close()
-
-    def return_classes_from_package(self, package_path):
-
-        onlyfiles = [f for f in listdir(package_path) if
-                     isfile(join(package_path, f))]
-        classes = []
-
-        for x in onlyfiles:
-            spec = importlib.util.spec_from_file_location(x[:-3], os.path.join(package_path, x))
-            foo = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(foo)
-            for name, obj in inspect.getmembers(foo):
-                if inspect.isclass(obj):
-                    classes.append(obj)
-
-        return classes

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/generator/handler/GetInstanceFieldGeneratorHandler.py

@@ -1,36 +0,0 @@
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-from javonet.utils.Command import Command
-from javonet.utils.CommandType import CommandType
-from javonet.utils.RuntimeName import RuntimeName
-
-
-class GetInstanceFieldGeneratorHandler(AbstractGeneratorHandler):
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        get_instance_field_command = Command(RuntimeName.python, CommandType.GetInstanceField, [])
-        get_instance_field_command = get_instance_field_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.METHOD_NAME].generate_command(analyzed_object.__name__,
-                                                                                    get_instance_field_command,
-                                                                                    handlers))
-        get_instance_field_command = get_instance_field_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.TYPE].generate_command(type(analyzed_object),
-                                                                             get_instance_field_command,
-                                                                             handlers))
-        get_instance_field_command = get_instance_field_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_command(analyzed_object.__name__,
-                                                                                 get_instance_field_command, handlers))
-        return get_instance_field_command
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        existing_string_builder.append("    ")
-        handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_code(existing_string_builder, common_command,
-                                                                          used_object.get_payload()[2], handlers)
-        handlers.SHARED_HANDLER[SharedHandlerType.METHOD_NAME].generate_code(existing_string_builder, common_command,
-                                                                             used_object.get_payload()[0], handlers)
-        existing_string_builder.append(" ")
-        existing_string_builder.append("=")
-        existing_string_builder.append(" ")
-        handlers.SHARED_BODY_HANDLER[CommandType.GetInstanceField].generate_code(existing_string_builder,
-                                                                                 common_command,
-                                                                                 used_object,
-                                                                                 handlers)