From 1c0fa1d8a4935110fb341beab7f0c8248e58e509 Mon Sep 17 00:00:00 2001 From: Umit UNAL Date: Thu, 17 Dec 2020 10:34:25 +0300 Subject: [PATCH 01/41] first codec generated. --- go/__init__.py | 299 +++++++++++++++++++++++++++++++++ go/codec-template.go.j2 | 146 ++++++++++++++++ go/custom-codec-template.go.j2 | 0 util.py | 17 +- 4 files changed, 457 insertions(+), 5 deletions(-) create mode 100644 go/custom-codec-template.go.j2 diff --git a/go/__init__.py b/go/__init__.py index e69de29bb..737c437eb 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -0,0 +1,299 @@ +go_reserved_keywords = {"break", "default", "func", "interface", "select", "case", "defer", "go", "map", "struct", + "chan", "else", "goto", "package", "switch", "const", "fallthrough", "if", "range", "type", + "continue", "for", "import", "return", "var"} + +go_ignore_service_list = {"MC", "Sql", "ExecutorService", "TransactionalMap", "TransactionalMultiMap", + "TransactionalSet", "TransactionalList", "TransactionalQueue", "Cache", "XATransaction", + "Transaction", "ContinuousQuery", "DurableExecutor", + "CardinalityEstimator", "ScheduledExecutor", "DynamicConfig", "CPSubsystem"} + + +def go_types_encode(key): + try: + return _go_types_encode[key] + except KeyError: + return _go_types_common[key] + + +def go_types_decode(key): + try: + return _go_types_decode[key] + except KeyError: + return _go_types_common[key] + + +def go_get_import_path_holders(param_type): + return import_paths.get(param_type, []) + + +class ImportPathHolder: + def __init__(self, name, path): + self.name = name + self.path = path + + def get_import_statement(self): + return "from hazelcast.%s import %s" % (self.path, self.name) + + +class PathHolders: + DataCodec = ImportPathHolder("DataCodec", "protocol.builtin") + ByteArrayCodec = ImportPathHolder("ByteArrayCodec", "protocol.builtin") + LongArrayCodec = ImportPathHolder("LongArrayCodec", "protocol.builtin") + Address = ImportPathHolder("Address", "core") + AddressCodec = ImportPathHolder("AddressCodec", "protocol.codec.custom.address_codec") + ErrorHolder = ImportPathHolder("ErrorHolder", "protocol") + ErrorHolderCodec = ImportPathHolder("ErrorHolderCodec", "protocol.codec.custom.error_holder_codec") + StackTraceElement = ImportPathHolder("StackTraceElement", "protocol") + StackTraceElementCodec = ImportPathHolder("StackTraceElementCodec", + "protocol.codec.custom.stack_trace_element_codec") + SimpleEntryView = ImportPathHolder("SimpleEntryView", "core") + SimpleEntryViewCodec = ImportPathHolder("SimpleEntryViewCodec", "protocol.codec.custom.simple_entry_view_codec") + DistributedObjectInfo = ImportPathHolder("DistributedObjectInfo", "core") + DistributedObjectInfoCodec = ImportPathHolder("DistributedObjectInfoCodec", + "protocol.codec.custom.distributed_object_info_codec") + MemberInfo = ImportPathHolder("MemberInfo", "core") + MemberInfoCodec = ImportPathHolder("MemberInfoCodec", "protocol.codec.custom.member_info_codec") + MemberVersion = ImportPathHolder("MemberVersion", "core") + MemberVersionCodec = ImportPathHolder("MemberVersionCodec", "protocol.codec.custom.member_version_codec") + StringCodec = ImportPathHolder("StringCodec", "protocol.builtin", ) + ListLongCodec = ImportPathHolder("ListLongCodec", "protocol.builtin") + ListIntegerCodec = ImportPathHolder("ListIntegerCodec", "protocol.builtin") + ListUUIDCodec = ImportPathHolder("ListUUIDCodec", "protocol.builtin") + ListDataCodec = ImportPathHolder("ListDataCodec", "protocol.builtin") + ListMultiFrameCodec = ImportPathHolder("ListMultiFrameCodec", "protocol.builtin") + EntryListCodec = ImportPathHolder("EntryListCodec", "protocol.builtin") + EntryListLongByteArrayCodec = ImportPathHolder("EntryListLongByteArrayCodec", "protocol.builtin") + EntryListIntegerUUIDCodec = ImportPathHolder("EntryListIntegerUUIDCodec", "protocol.builtin") + EntryListIntegerLongCodec = ImportPathHolder("EntryListIntegerLongCodec", "protocol.builtin") + EntryListIntegerIntegerCodec = ImportPathHolder("EntryListIntegerIntegerCodec", "protocol.builtin") + EntryListUUIDLongCodec = ImportPathHolder("EntryListUUIDLongCodec", "protocol.builtin") + EntryListUUIDUUIDCodec = ImportPathHolder("EntryListUUIDUUIDCodec", "protocol.builtin") + EntryListUUIDListIntegerCodec = ImportPathHolder("EntryListUUIDListIntegerCodec", "protocol.builtin") + MapCodec = ImportPathHolder("MapCodec", "protocol.builtin") + CodecUtil = ImportPathHolder("CodecUtil", "protocol.builtin") + IndexConfig = ImportPathHolder("IndexConfig", "config") + IndexConfigCodec = ImportPathHolder("IndexConfigCodec", "protocol.codec.custom.index_config_codec") + BitmapIndexOptions = ImportPathHolder("BitmapIndexOptions", "config") + BitmapIndexOptionsCodec = ImportPathHolder("BitmapIndexOptionsCodec", + "protocol.codec.custom.bitmap_index_options_codec") + PagingPredicateHolder = ImportPathHolder("PagingPredicateHolder", "protocol") + PagingPredicateHolderCodec = ImportPathHolder("PagingPredicateHolderCodec", + "protocol.codec.custom.paging_predicate_holder_codec") + AnchorDataListHolder = ImportPathHolder("AnchorDataListHolder", "protocol") + AnchorDataListHolderCodec = ImportPathHolder("AnchorDataListHolderCodec", + "protocol.codec.custom.anchor_data_list_holder_codec") + EndpointQualifier = ImportPathHolder("EndpointQualifier", "protocol") + EndpointQualifierCodec = ImportPathHolder("EndpointQualifierCodec", + "protocol.codec.custom.endpoint_qualifier_codec") + RaftGroupId = ImportPathHolder("RaftGroupId", "protocol") + RaftGroupIdCodec = ImportPathHolder("RaftGroupIdCodec", "protocol.codec.custom.raft_group_id_codec") + + +import_paths = { + "CodecUtil": PathHolders.CodecUtil, + "longArray": [PathHolders.LongArrayCodec], + "byteArray": [PathHolders.ByteArrayCodec], + "String": [PathHolders.StringCodec], + "Data": [PathHolders.DataCodec], + "Address": [PathHolders.Address, PathHolders.AddressCodec], + "ErrorHolder": [PathHolders.ErrorHolder, PathHolders.ErrorHolderCodec], + "StackTraceElement": [PathHolders.StackTraceElement, PathHolders.StackTraceElementCodec], + "SimpleEntryView": [PathHolders.SimpleEntryView, PathHolders.SimpleEntryViewCodec], + "DistributedObjectInfo": [PathHolders.DistributedObjectInfo, PathHolders.DistributedObjectInfoCodec], + "MemberInfo": [PathHolders.MemberInfo, PathHolders.MemberInfoCodec], + "MemberVersion": [PathHolders.MemberVersion, PathHolders.MemberVersionCodec], + "RaftGroupId": [PathHolders.RaftGroupId, PathHolders.RaftGroupIdCodec], + "List_Long": [PathHolders.ListLongCodec], + "List_Integer": [PathHolders.ListIntegerCodec], + "List_UUID": [PathHolders.ListUUIDCodec], + "List_String": [PathHolders.ListMultiFrameCodec, PathHolders.StringCodec], + "List_Data": [PathHolders.ListMultiFrameCodec, PathHolders.DataCodec], + "ListCN_Data": [PathHolders.ListMultiFrameCodec, PathHolders.DataCodec], + "List_MemberInfo": [PathHolders.ListMultiFrameCodec, PathHolders.MemberInfoCodec], + "List_DistributedObjectInfo": [PathHolders.ListMultiFrameCodec, PathHolders.DistributedObjectInfoCodec], + "List_StackTraceElement": [PathHolders.ListMultiFrameCodec, PathHolders.StackTraceElementCodec], + "EntryList_String_String": [PathHolders.EntryListCodec, PathHolders.StringCodec], + "EntryList_String_byteArray": [PathHolders.EntryListCodec, PathHolders.StringCodec, PathHolders.ByteArrayCodec], + "EntryList_Long_byteArray": [PathHolders.EntryListLongByteArrayCodec], + "EntryList_Integer_UUID": [PathHolders.EntryListIntegerUUIDCodec], + "EntryList_Integer_Long": [PathHolders.EntryListIntegerLongCodec], + "EntryList_Integer_Integer": [PathHolders.EntryListIntegerIntegerCodec], + "EntryList_UUID_Long": [PathHolders.EntryListUUIDLongCodec], + "EntryList_String_EntryList_Integer_Long": [PathHolders.EntryListCodec, PathHolders.StringCodec, + PathHolders.EntryListIntegerLongCodec], + "EntryList_UUID_UUID": [PathHolders.EntryListUUIDUUIDCodec], + "EntryList_UUID_List_Integer": [PathHolders.EntryListUUIDListIntegerCodec], + "EntryList_Data_Data": [PathHolders.EntryListCodec, PathHolders.DataCodec], + "EntryList_Data_List_Data": [PathHolders.EntryListCodec, PathHolders.DataCodec, PathHolders.ListDataCodec], + "Map_String_String": [PathHolders.MapCodec, PathHolders.StringCodec], + "IndexConfig": [PathHolders.IndexConfig, PathHolders.IndexConfigCodec], + "ListIndexConfig": [PathHolders.IndexConfigCodec, PathHolders.ListMultiFrameCodec], + "BitmapIndexOptions": [PathHolders.BitmapIndexOptions, PathHolders.BitmapIndexOptionsCodec], + "AnchorDataListHolder": [PathHolders.AnchorDataListHolder, PathHolders.AnchorDataListHolderCodec], + "PagingPredicateHolder": [PathHolders.PagingPredicateHolder, PathHolders.PagingPredicateHolderCodec], + "EndpointQualifier": [PathHolders.EndpointQualifier, PathHolders.EndpointQualifierCodec], + "Map_EndpointQualifier_Address": [PathHolders.MapCodec, PathHolders.EndpointQualifierCodec, + PathHolders.AddressCodec] +} + +_go_types_common = { + "boolean": "bool", + "int": "int32", + "long": "int64", + "byte": "byte", + "Integer": "int32", + "Long": "int64", + "UUID": "core.UUID", + + "longArray": "[]int64", + "byteArray": "[]byte", + "String": "string", + "Data": "serialization.Data", + + "Address": "Address", + "ErrorHolder": "com.hazelcast.client.impl.protocol.exception.ErrorHolder", + "StackTraceElement": "StackTraceElement", + "SimpleEntryView": "Pair", + "RaftGroupId": "NA", + "WanReplicationRef": "NA", + "HotRestartConfig": "NA", + "EventJournalConfig": "NA", + "MerkleTreeConfig": "NA", + "TimedExpiryPolicyFactoryConfig": "NA", + "QueueStoreConfigHolder": "NA", + "RingbufferStoreConfigHolder": "NA", + "NearCacheConfigHolder": "NA", + "EvictionConfigHolder": "NA", + "NearCachePreloaderConfig": "NA", + "PredicateConfigHolder": "NA", + "DurationConfig": "NA", + + "MergePolicyConfig": "NA", + "CacheConfigHolder": "NA", + "CacheEventData": "NA", + "QueryCacheConfigHolder": "NA", + "MapStoreConfigHolder": "NA", + "DistributedObjectInfo": "NA", + "IndexConfig": "NA", + "BitmapIndexOptions": "NA", + "AttributeConfig": "NA", + "ListenerConfigHolder": "NA", + "CacheSimpleEntryListenerConfig": "NA", + "ClientBwListEntry": "NA", + "EndpointQualifier": "NA", + + "Map_String_String": "NA", + "Map_EndpointQualifier_Address": "NA", + + "List_CPMember": "NA" +} + +_go_types_encode = { + "CacheEventData": "NA", + "QueryCacheEventData": "NA", + "ScheduledTaskHandler": "NA", + "Xid": "NA", + "ClientBwListEntry": "NA", + "MemberInfo": "NA", + "MemberVersion": "NA", + "MCEvent": "NA", + "AnchorDataListHolder": "NA", + "PagingPredicateHolder": "NA", + "SqlQueryId": "NA", + "SqlError": "NA", + "SqlColumnMetadata": "NA", + "CPMember": "NA", + "MigrationState": "NA", + + "List_Long": "java.util.Collection", + "List_Integer": "java.util.Collection", + "List_UUID": "java.util.Collection", + "List_String": "[]string", + "List_Xid": "java.util.Collection", + "List_Data": "[]serialization.Data", + "List_List_Data": "java.util.Collection>", + "ListCN_Data": "java.util.Collection", + "List_ListCN_Data": "java.util.Collection>", + "List_MemberInfo": "java.util.Collection", + "List_ScheduledTaskHandler": "java.util.Collection", + "List_CacheEventData": "java.util.Collection", + "List_QueryCacheConfigHolder": "java.util.Collection", + "List_DistributedObjectInfo": "java.util.Collection", + "List_QueryCacheEventData": "java.util.Collection", + "List_IndexConfig": "java.util.Collection", + "List_AttributeConfig": "java.util.Collection", + "List_ListenerConfigHolder": "java.util.Collection", + "List_CacheSimpleEntryListenerConfig": "java.util.Collection", + "List_StackTraceElement": "java.util.Collection", + "List_ClientBwListEntry": "java.util.Collection", + "List_MCEvent": "java.util.Collection", + "List_SqlColumnMetadata": "java.util.List", + + "EntryList_String_String": "java.util.Collection>", + "EntryList_String_byteArray": "java.util.Collection>", + "EntryList_Long_byteArray": "java.util.Collection>", + "EntryList_Integer_UUID": "java.util.Collection>", + "EntryList_Integer_Long": "java.util.Collection>", + "EntryList_Integer_Integer": "java.util.Collection>", + "EntryList_UUID_Long": "java.util.Collection>", + "EntryList_String_EntryList_Integer_Long": "java.util.Collection>>>", + "EntryList_UUID_UUID": "java.util.Collection>", + "EntryList_UUID_List_Integer": "java.util.Collection>>", + "EntryList_Data_Data": "java.util.Collection>", + "EntryList_Data_List_Data": "java.util.Collection>>", +} + +_go_types_decode = { + "CacheEventData": "com.hazelcast.cache.impl.CacheEventDataImpl", + "QueryCacheEventData": "com.hazelcast.map.impl.querycache.event.DefaultQueryCacheEventData", + "ScheduledTaskHandler": "com.hazelcast.scheduledexecutor.impl.ScheduledTaskHandlerImpl", + "Xid": "com.hazelcast.transaction.impl.xa.SerializableXID", + "ClientBwListEntry": "com.hazelcast.internal.management.dto.ClientBwListEntryDTO", + "MemberInfo": "com.hazelcast.internal.cluster.MemberInfo", + "MemberVersion": "com.hazelcast.version.MemberVersion", + "MCEvent": "com.hazelcast.internal.management.dto.MCEventDTO", + "AnchorDataListHolder": "com.hazelcast.client.impl.protocol.codec.holder.AnchorDataListHolder", + "PagingPredicateHolder": "com.hazelcast.client.impl.protocol.codec.holder.PagingPredicateHolder", + "SqlQueryId": "com.hazelcast.sql.impl.QueryId", + "SqlError": "com.hazelcast.sql.impl.client.SqlError", + "SqlColumnMetadata": "com.hazelcast.sql.SqlColumnMetadata", + "CPMember": "com.hazelcast.cp.internal.CPMemberInfo", + "MigrationState": "com.hazelcast.internal.partition.MigrationStateImpl", + + "List_Long": "java.util.List", + "List_Integer": "java.util.List", + "List_UUID": "java.util.List", + "List_Xid": "java.util.List", + "List_String": "java.util.List", + "List_Data": "java.util.List", + "List_List_Data": "java.util.List>", + "ListCN_Data": "java.util.List", + "List_ListCN_Data": "java.util.List>", + "List_MemberInfo": "java.util.List", + "List_CacheEventData": "java.util.List", + "List_QueryCacheConfigHolder": "java.util.List", + "List_DistributedObjectInfo": "java.util.List", + "List_QueryCacheEventData": "java.util.List", + "List_IndexConfig": "java.util.List", + "List_AttributeConfig": "java.util.List", + "List_ListenerConfigHolder": "java.util.List", + "List_CacheSimpleEntryListenerConfig": "java.util.List", + "List_StackTraceElement": "java.util.List", + "List_ClientBwListEntry": "java.util.List", + "List_MCEvent": "java.util.List", + "List_ScheduledTaskHandler": "java.util.Collection", + "List_SqlColumnMetadata": "java.util.List", + + "EntryList_String_String": "java.util.List>", + "EntryList_String_byteArray": "java.util.List>", + "EntryList_Long_byteArray": "java.util.List>", + "EntryList_Integer_UUID": "java.util.List>", + "EntryList_Integer_Long": "java.util.List>", + "EntryList_Integer_Integer": "java.util.List>", + "EntryList_UUID_Long": "java.util.List>", + "EntryList_String_EntryList_Integer_Long": "java.util.List>>>", + "EntryList_UUID_UUID": "java.util.List>", + "EntryList_UUID_List_Integer": "java.util.List>>", + "EntryList_Data_Data": "java.util.List>", + "EntryList_Data_List_Data": "java.util.List>>", +} diff --git a/go/codec-template.go.j2 b/go/codec-template.go.j2 index e69de29bb..675c0cea7 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.go.j2 @@ -0,0 +1,146 @@ +{% macro encode_var_sized(param, loop_last) -%} + {% if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} + codecBuiltin.ListMultiFrameCodec.EncodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type)%}_contains_nullable{% endif %}{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}{% if loop_last %}, True{% endif %}) + {%- elif is_var_sized_entry_list(param.type) -%} + codecBuiltin.EntryListCodec.Encode{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}, {{ key_type(lang_name, param.type) }}Codec.Encode, {{ value_type(lang_name, param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) + {%- elif is_var_sized_map(param.type) -%} + codecBuiltin.MapCodec.Encode{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}, {{ key_type(lang_name, param.type) }}Codec.Encode, {{ value_type(lang_name, param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) + {%- else -%} + {%- if param.nullable -%} + codecBuiltin.CodecUtil.EncodeNullable(clientMessage, {{ param_name(param.name) }}, {{ lang_name(param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) + {%- else -%} + codecBuiltin.{{ lang_name(param.type) }}Codec.Encode(clientMessage, {{ param_name(param.name) }}{% if loop_last %}, True{% endif %}) + {%- endif %} + {% endif %} +{%- endmacro %} +{% macro decode_var_sized(param) -%} + {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} + codecBuiltin.ListMultiFrameCodec.decode{% if is_var_sized_list_contains_nullable(param.type) %}_contains_nullable{% endif %}{% if param.nullable %}_nullable{% endif %}(msg, {{ item_type(lang_name, param.type) }}Codec.decode) + {%- elif is_var_sized_entry_list(param.type) -%} + codecBuiltin.EntryListCodec.decode{% if param.nullable %}_nullable{% endif %}(msg, {{ key_type(lang_name, param.type) }}Codec.decode, {{ value_type(lang_name, param.type) }}Codec.decode) + {%- elif is_var_sized_map(param.type) -%} + codecBuiltin.MapCodec.decode{% if param.nullable %}_nullable{% endif %}(msg, {{ key_type(lang_name, param.type) }}Codec.decode, {{ value_type(lang_name, param.type) }}Codec.decode) + {%- else -%} + {%- if param.nullable -%} + codecBuiltin.CodecUtil.decode_nullable(msg, {{ lang_name(param.type) }}Codec.decode) + {%- else -%} + codecBuiltin.{{ lang_name(param.type) }}Codec.decode(msg) + {%- endif -%} + {%- endif -%} +{%- endmacro %} +{% macro get_import_statements() -%} + {% set imported_paths = [] %} + {%- for params in varargs -%} + {% for param in params %} + {% set path_holders = get_import_path_holders(param.type) %} + {%- for path_holder in path_holders -%} + {% if not path_holder.name in imported_paths and path_holder.name.endswith('Codec') %} + {%- do imported_paths.append(path_holder.name) -%} + {{ path_holder.get_import_statement() }} + {% endif %} + {% endfor %} + {% if not (is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) or is_var_sized_entry_list(param.type) or is_var_sized_map(param.type)) and param.nullable and param.type != 'UUID' and not 'CodecUtil' in imported_paths %} + {%- do imported_paths.append('CodecUtil') -%} + {{ get_import_path_holders('CodecUtil').get_import_statement() }} + {% endif %} + {%- endfor -%} + {%- endfor -%} +{%- endmacro %} +{% set request_fix_sized_params = fixed_params(method.request.params) %} +{% set request_var_sized_params = var_size_params(method.request.params) %} + +// Copyright (c) 2008-2020, Hazelcast, Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package proto + +import ( + "github.com/hazelcast/hazelcast-go-client/hazelcast/core" + "github.com/hazelcast/hazelcast-go-client/hazelcast/internal/protocol" + codecBuiltin "github.com/hazelcast/hazelcast-go-client/hazelcast/internal/protocol/codec/builtin" +) + +const( + // hex: {{ '0x%06X'|format(method.request.id) }} + {{ service_name|capital }}{{ method.name|capital }}CodecRequestMessageType int32 = {{ method.request.id }} + // hex: {{ '0x%06X'|format(method.response.id) }} + {{ service_name|capital }}{{ method.name|capital }}CodecResponseMessageType int32 = {{ method.response.id }} +{% for event in method.events%} + // hex: {{ '0x%06X'|format(event.id) }} + {{ service_name|capital }}{{ method.name|capital }}CodecEvent{{ event.name|capital }}MessageType int32 = {{ event.id }} +{% endfor %} +{#FIXED SIZED PARAMETER OFFSET CONSTANTS#} +{% for param in request_fix_sized_params %} + {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset = {% if loop.first %}protocol.PartitionIDOffset + protocol.IntSizeInBytes{% else %}protocol.Request{{ loop.previtem.name|capital }}Offset + protocol.{{ loop.previtem.type|capitalize }}SizeInBytes{% endif %} + + {% if loop.last %} + {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize = protocol.Request{{ param.name|capital }}Offset + protocol.{{ param.type|capitalize }}SizeInBytes + + {% endif %} +{% else %} + {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize = protocol.PartitionIDOffset + protocol.IntSizeInBytes + +{% endfor %} +{% for event in method.events %} + {% for param in fixed_params(event.params) %} + {{ service_name|capital }}{{ method.name|capital }}Event{{ event.name|capital }}{{param.name|capital}}Offset = {% if loop.first %}protocol.PartitionIDOffset + protocol.IntSizeInBytes{% else %}1EVENT_{{ to_upper_snake_case(event.name)}}_{{ to_upper_snake_case(loop.previtem.name)}}_Offset + protocol.{{loop.previtem.type|capitalize}}SizeInBytes{% endif %} + {% endfor %} +{% endfor %} +) +{#RESPONSE PARAMETERS#} +{% set noResponseValue = method.response.params|length == 0 %} +{% set singleResponseValue = method.response.params|length == 1 and response_new_params|length == 0 %} +{% if not (noResponseValue or singleResponseValue) %} + +/** @internal */ +type {{ service_name|capital }}{{ method.name|capital }}ResponseParams struct { +{% for param in method.response.params %} + {{ escape_keyword(param.name)|capital}} {{ lang_types_encode(param.type) }} +{% endfor %} +{% for new_param in response_new_params %} + is{{ new_param.name|capital }}Exists: boolean; +{% endfor %} +} +{% endif %} + + +{% for line in method.doc.splitlines() %} +// {{ line }} +{% endfor %} +type {{ service_name|lower }}{{ method.name|capital }}Codec struct {} + +var {{ service_name|capital }}{{ method.name|capital }}Codec {{ service_name|lower }}{{ method.name|capital }}Codec + +func ({{ service_name|lower }}{{ method.name|capital }}Codec) Encode({% for param in method.request.params %}{{ escape_keyword(param.name) }} {{ lang_types_encode(param.type) }}{% if not loop.last %}, {% endif %}{% endfor %}) *protocol.ClientMessage { + clientMessage := protocol.NewClientMessageForEncode() + clientMessage.SetRetryable({{ method.request.retryable|lower }}) + + initialFrame := protocol.NewFrame(make([]byte, {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize)) +{% for param in request_fix_sized_params %} + codecBuiltin.FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset, {{ escape_keyword(param.name) }}) +{% endfor %} + clientMessage.AddFrame(initialFrame) + clientMessage.SetMessageType({{ service_name|capital }}{{ method.name|capital }}CodecRequestMessageType) + clientMessage.SetPartitionId(-1) + +{% for param in request_var_sized_params %} + {{ encode_var_sized(param) }} +{% endfor %} + + return clientMessage +} + +func ({{ service_name|lower }}{{ method.name|capital }}Codec) Decode() { + +} diff --git a/go/custom-codec-template.go.j2 b/go/custom-codec-template.go.j2 new file mode 100644 index 000000000..e69de29bb diff --git a/util.py b/util.py index 72add9495..ae47a808d 100644 --- a/util.py +++ b/util.py @@ -11,6 +11,7 @@ from binary import FixedLengthTypes, FixedListTypes, FixedEntryListTypes, FixedMapTypes from java import java_types_encode, java_types_decode +from go import go_types_encode, go_types_decode, go_ignore_service_list, go_get_import_path_holders from cs import cs_types_encode, cs_types_decode, cs_escape_keyword, cs_ignore_service_list from cpp import cpp_types_encode, cpp_types_decode, cpp_ignore_service_list, get_size, is_trivial from ts import ts_types_encode, ts_types_decode, ts_escape_keyword, ts_ignore_service_list, ts_get_import_path_holders @@ -376,7 +377,7 @@ class SupportedLanguages(Enum): CS = 'cs' PY = 'py' TS = 'ts' - # GO = 'go' + GO = 'go' codec_output_directories = { @@ -385,7 +386,7 @@ class SupportedLanguages(Enum): SupportedLanguages.CS: 'src/Hazelcast.Net/Protocol/Codecs/', SupportedLanguages.PY: 'hazelcast/protocol/codec/', SupportedLanguages.TS: 'src/codec/', - # SupportedLanguages.GO: 'internal/proto/' + SupportedLanguages.GO: 'internal/proto/' } custom_codec_output_directories = { @@ -394,7 +395,7 @@ class SupportedLanguages(Enum): SupportedLanguages.CS: 'src/Hazelcast.Net/Protocol/CustomCodecs/', SupportedLanguages.PY: 'hazelcast/protocol/codec/custom/', SupportedLanguages.TS: 'src/codec/custom', - # SupportedLanguages.GO: 'internal/proto/' + SupportedLanguages.GO: 'internal/proto/' } @@ -416,7 +417,7 @@ def inner(*names): SupportedLanguages.CS: _capitalized_name_generator('cs'), SupportedLanguages.PY: _snake_cased_name_generator('py'), SupportedLanguages.TS: _capitalized_name_generator('ts'), - # SupportedLanguages.GO: 'go' + SupportedLanguages.GO: _snake_cased_name_generator('go'), } language_specific_funcs = { @@ -426,6 +427,7 @@ def inner(*names): SupportedLanguages.CPP: cpp_types_encode, SupportedLanguages.TS: ts_types_encode, SupportedLanguages.PY: py_types_encode_decode, + SupportedLanguages.GO: go_types_encode, }, 'lang_types_decode': { SupportedLanguages.JAVA: java_types_decode, @@ -433,6 +435,7 @@ def inner(*names): SupportedLanguages.CPP: cpp_types_decode, SupportedLanguages.TS: ts_types_decode, SupportedLanguages.PY: py_types_encode_decode, + SupportedLanguages.GO: go_types_decode, }, 'lang_name': { SupportedLanguages.JAVA: java_name, @@ -440,6 +443,7 @@ def inner(*names): SupportedLanguages.CPP: cpp_name, SupportedLanguages.TS: java_name, SupportedLanguages.PY: java_name, + SupportedLanguages.GO: java_name, }, 'param_name': { SupportedLanguages.JAVA: param_name, @@ -447,6 +451,7 @@ def inner(*names): SupportedLanguages.CPP: param_name, SupportedLanguages.TS: param_name, SupportedLanguages.PY: py_param_name, + SupportedLanguages.GO: param_name, }, 'escape_keyword': { SupportedLanguages.JAVA: lambda x: x, @@ -454,6 +459,7 @@ def inner(*names): SupportedLanguages.CPP: lambda x: x, SupportedLanguages.TS: ts_escape_keyword, SupportedLanguages.PY: py_escape_keyword, + SupportedLanguages.GO: lambda x: x, }, 'get_import_path_holders': { SupportedLanguages.JAVA: lambda x: x, @@ -461,6 +467,7 @@ def inner(*names): SupportedLanguages.CPP: lambda x: x, SupportedLanguages.TS: ts_get_import_path_holders, SupportedLanguages.PY: py_get_import_path_holders, + SupportedLanguages.GO: go_get_import_path_holders, } } @@ -470,7 +477,7 @@ def inner(*names): SupportedLanguages.CS: cs_ignore_service_list, SupportedLanguages.PY: py_ignore_service_list, SupportedLanguages.TS: ts_ignore_service_list, - # SupportedLanguages.GO: set() + SupportedLanguages.GO: go_ignore_service_list, } From 6ffdf3ee209ca763ebee5b687b1f7b36bb6787b1 Mon Sep 17 00:00:00 2001 From: Umit UNAL Date: Fri, 18 Dec 2020 09:06:19 +0300 Subject: [PATCH 02/41] first codec generated. --- go/__init__.py | 8 +- go/codec-template.go.j2 | 87 +++++++++++++-- go/custom-codec-template.go.j2 | 186 +++++++++++++++++++++++++++++++++ 3 files changed, 268 insertions(+), 13 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index 737c437eb..8adf54445 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -150,7 +150,7 @@ class PathHolders: "String": "string", "Data": "serialization.Data", - "Address": "Address", + "Address": "core.Address", "ErrorHolder": "com.hazelcast.client.impl.protocol.exception.ErrorHolder", "StackTraceElement": "StackTraceElement", "SimpleEntryView": "Pair", @@ -264,15 +264,15 @@ class PathHolders: "List_Integer": "java.util.List", "List_UUID": "java.util.List", "List_Xid": "java.util.List", - "List_String": "java.util.List", - "List_Data": "java.util.List", + "List_String": "[]string", + "List_Data": "[]serialization.Data", "List_List_Data": "java.util.List>", "ListCN_Data": "java.util.List", "List_ListCN_Data": "java.util.List>", "List_MemberInfo": "java.util.List", "List_CacheEventData": "java.util.List", "List_QueryCacheConfigHolder": "java.util.List", - "List_DistributedObjectInfo": "java.util.List", + "List_DistributedObjectInfo": "[]core.DistributedObjectInfo", "List_QueryCacheEventData": "java.util.List", "List_IndexConfig": "java.util.List", "List_AttributeConfig": "java.util.List", diff --git a/go/codec-template.go.j2 b/go/codec-template.go.j2 index 675c0cea7..977a1f096 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.go.j2 @@ -15,16 +15,16 @@ {%- endmacro %} {% macro decode_var_sized(param) -%} {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - codecBuiltin.ListMultiFrameCodec.decode{% if is_var_sized_list_contains_nullable(param.type) %}_contains_nullable{% endif %}{% if param.nullable %}_nullable{% endif %}(msg, {{ item_type(lang_name, param.type) }}Codec.decode) + codecBuiltin.ListMultiFrameCodec.DecodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type) %}_contains_nullable{% endif %}{% if param.nullable %}_nullable{% endif %}(frameIterator) {%- elif is_var_sized_entry_list(param.type) -%} - codecBuiltin.EntryListCodec.decode{% if param.nullable %}_nullable{% endif %}(msg, {{ key_type(lang_name, param.type) }}Codec.decode, {{ value_type(lang_name, param.type) }}Codec.decode) + codecBuiltin.EntryListCodec.Decode{% if param.nullable %}Nullable{% endif %}(msg, {{ key_type(lang_name, param.type) }}Codec.decode, {{ value_type(lang_name, param.type) }}Codec.decode) {%- elif is_var_sized_map(param.type) -%} - codecBuiltin.MapCodec.decode{% if param.nullable %}_nullable{% endif %}(msg, {{ key_type(lang_name, param.type) }}Codec.decode, {{ value_type(lang_name, param.type) }}Codec.decode) + codecBuiltin.MapCodec.Decode{% if param.nullable %}Nullable{% endif %}(msg, {{ key_type(lang_name, param.type) }}Codec.decode, {{ value_type(lang_name, param.type) }}Codec.decode) {%- else -%} {%- if param.nullable -%} - codecBuiltin.CodecUtil.decode_nullable(msg, {{ lang_name(param.type) }}Codec.decode) + codecBuiltin.CodecUtil.DecodeNullable(msg, {{ lang_name(param.type) }}Codec.decode) {%- else -%} - codecBuiltin.{{ lang_name(param.type) }}Codec.decode(msg) + codecBuiltin.{{ lang_name(param.type) }}Codec.Decode(msg) {%- endif -%} {%- endif -%} {%- endmacro %} @@ -48,7 +48,17 @@ {%- endmacro %} {% set request_fix_sized_params = fixed_params(method.request.params) %} {% set request_var_sized_params = var_size_params(method.request.params) %} - +{% set response_fix_sized_params = fixed_params(method.response.params) %} +{% set response_var_sized_params = var_size_params(method.response.params) %} +{% set response_new_params = new_params(method.since, method.response.params) %} +{% set event_fix_sized_params = [] %} +{% set event_var_sized_params = [] %} +{% if method.events|length != 0 %} + {% for event in method.events %} + {% do event_fix_sized_params.extend(fixed_params(event.params)) %} + {% do event_var_sized_params.extend(var_size_params(event.params)) %} + {% endfor %} +{% endif %} // Copyright (c) 2008-2020, Hazelcast, Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); @@ -90,11 +100,13 @@ const( {% endif %} {% else %} {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize = protocol.PartitionIDOffset + protocol.IntSizeInBytes - +{% endfor %} +{% for param in response_fix_sized_params %} + {{ service_name|capital }}{{ method.name|capital }}Response{{ param.name|capital }}Offset = {% if loop.first %}protocol.ResponseBackupAcksOffset + protocol.ByteSizeInBytes{% else %}RESPONSE_{{ to_upper_snake_case(loop.previtem.name)}}_OFFSET + BitsUtil.{{loop.previtem.type.upper()}}_SIZE_IN_BYTES{% endif %} {% endfor %} {% for event in method.events %} {% for param in fixed_params(event.params) %} - {{ service_name|capital }}{{ method.name|capital }}Event{{ event.name|capital }}{{param.name|capital}}Offset = {% if loop.first %}protocol.PartitionIDOffset + protocol.IntSizeInBytes{% else %}1EVENT_{{ to_upper_snake_case(event.name)}}_{{ to_upper_snake_case(loop.previtem.name)}}_Offset + protocol.{{loop.previtem.type|capitalize}}SizeInBytes{% endif %} + {{ service_name|capital }}{{ method.name|capital }}Event{{ event.name|capital }}{{param.name|capital}}Offset = {% if loop.first %}protocol.PartitionIDOffset + protocol.IntSizeInBytes{% else %}{{ service_name|capital }}{{ method.name|capital }}Event{{ event.name|capital }}{{ loop.previtem.name|capital }}Offset + protocol.{{loop.previtem.type|capitalize}}SizeInBytes{% endif %} {% endfor %} {% endfor %} ) @@ -141,6 +153,63 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) Encode({% for para return clientMessage } -func ({{ service_name|lower }}{{ method.name|capital }}Codec) Decode() { +{#RESPONSE DECODE#} +{% if noResponseValue %} +{% elif singleResponseValue %} + {% set param = method.response.params|last %} + +func ({{ service_name|lower }}{{ method.name|capital }}Codec) Decode(clientMessage protocol.ClientMessage) {{ lang_types_decode(param.type) }} { + frameIterator := clientMessage.FrameIterator() +{% if response_fix_sized_params|length != 0 %} + initialFrame := frameIterator.Next() +{% else %} + // empty initial frame + frameIterator.Next() +{% endif %} + +{% for param in response_fix_sized_params %} + return codecBuiltin.FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Response{{param.name|capital}}Offset) +{% endfor %} +{% for param in response_var_sized_params %} + return {{ decode_var_sized(param) }} +{% endfor %} +} +{% else %} + +func ({{ service_name|lower }}{{ method.name|capital }}Codec) Decode() { {{ service_name|capital }}{{ method.name|capital }}ResponseParams { +{% if response_fix_sized_params|length != 0 %} + const initialFrame = clientMessage.nextFrame() +{% else %} + // empty initial frame + clientMessage.nextFrame() +{% endif %} +const response = {} as {{ service_name|capital }}{{ method.name|capital }}ResponseParams; +{% for param in response_fix_sized_params %} + {% if param in response_new_params %} + if (initialFrame.content.length >= RESPONSE_{{ to_upper_snake_case(param.name) }}_OFFSET + BitsUtil.{{ param.type.upper() }}_SIZE_IN_BYTES) { + response.{{ escape_keyword(param.name) }} = FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.content, RESPONSE_{{to_upper_snake_case(param.name)}}_OFFSET); + response.is{{ param.name|capital }}Exists = true; + } else { + response.is{{ param.name|capital }}Exists = false; + } + {% else %} + response.{{ escape_keyword(param.name) }} = FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.content, RESPONSE_{{to_upper_snake_case(param.name)}}_OFFSET); + {% endif %} +{% endfor %} +{% for param in response_var_sized_params %} + {% if param in response_new_params %} + if (clientMessage.hasNextFrame()) { + response.{{ escape_keyword(param.name) }} = {{ decode_var_sized(param) }}; + response.is{{ param.name|capital }}Exists = true; + } else { + response.is{{ param.name|capital }}Exists = false; + } + {% else %} + response.{{ escape_keyword(param.name) }} = {{ decode_var_sized(param) }}; + {% endif %} +{% endfor %} + +return response; } +{% endif %} diff --git a/go/custom-codec-template.go.j2 b/go/custom-codec-template.go.j2 index e69de29bb..11b309112 100644 --- a/go/custom-codec-template.go.j2 +++ b/go/custom-codec-template.go.j2 @@ -0,0 +1,186 @@ +{% macro encode_var_sized(param) -%} + {% if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} + ListMultiFrameCodec.encode{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}(), {{ item_type(lang_name, param.type) }}Codec::encode) + {%- elif is_var_sized_entry_list(param.type) -%} + EntryListCodec.encode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}(), {{ key_type(lang_name, param.type) }}Codec::encode, {{ value_type(lang_name, param.type) }}Codec::encodeNullable) + {%- elif is_var_sized_map(param.type) -%} + MapCodec.encode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}(), {{ key_type(lang_name, param.type) }}Codec::encode, {{ value_type(lang_name, param.type) }}Codec::encode) + {%- else -%} + {%- if param.nullable -%} + CodecUtil.encodeNullable(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}(), {{ lang_name(param.type) }}Codec::encode) + {%- else -%} + {{ lang_name(param.type) }}Codec.Encode(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}()) + {%- endif %} + {% endif %} +{%- endmacro %} +{% macro decode_var_sized(param) -%} + {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} + ListMultiFrameCodec.decode{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(iterator, {{ item_type(lang_name, param.type) }}Codec::decode) + {%- elif is_var_sized_entry_list(param.type) -%} + EntryListCodec.decode{% if param.nullable %}Nullable{% endif %}(iterator, {{ key_type(lang_name, param.type) }}Codec::decode, {{ value_type(lang_name, param.type) }}Codec::decodeNullable) + {%- elif is_var_sized_map(param.type) -%} + MapCodec.decode{% if param.nullable %}Nullable{% endif %}(iterator, {{ key_type(lang_name, param.type) }}Codec::decode, {{ value_type(lang_name, param.type) }}Codec::decode) + {%- else -%} + {%- if param.nullable -%} + CodecUtil.decodeNullable(iterator, {{ lang_name(param.type) }}Codec::decode) + {%- else -%} + {{ lang_name(param.type) }}Codec.decode(iterator) + {%- endif -%} + {%- endif -%} +{%- endmacro %} +/* +* Copyright (c) 2008-2020, Hazelcast, Inc. All Rights Reserved. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +package proto + +import ( + "github.com/hazelcast/hazelcast-go-client/hazelcast/core" + "github.com/hazelcast/hazelcast-go-client/hazelcast/internal/protocol" + codecBuiltin "github.com/hazelcast/hazelcast-go-client/hazelcast/internal/protocol/codec/builtin" +) + +{% set fix_sized_params = fixed_params(codec.params) %} +{% set var_sized_params = var_size_params(codec.params) %} +{% set new_codec_params = new_params(codec.since, codec.params) %} +{% set fix_sized_new_params = new_params(codec.since, fix_sized_params) %} +{% set should_add_begin_frame = (fix_sized_params|length > fix_sized_new_params|length) or fix_sized_params|length == 0 %} + +const( +{% for param in fix_sized_params %} + {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset = {% if loop.first %}0{% else %}{{ to_upper_snake_case(loop.previtem.name)}}_FIELD_OFFSET + {{ loop.previtem.type.upper() }}_SIZE_IN_BYTES{% endif %} + + {% if loop.last %} + {{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize = {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset + protocol.{{ param.type }}SizeInBytes; + {% endif %} +{% endfor %} +) + +type {{ codec.name|lower }}Codec struct {} + +var {{ codec.name|capital }}Codec {{ codec.name|lower }}Codec + +func ({{ codec.name|lower }}Codec) Encode(clientMessage protocol.ClientMessage, {{ param_name(codec.name) }} {{ lang_types_encode(codec.name) }}){ + +{% if should_add_begin_frame %} + clientMessage.AddFrame(protocol.BeginFrame.Copy()) +{% endif %} +{% for param in fix_sized_params %} + {% if loop.first %} + initialFrame := protocol.NewFrame(make([]byte,{{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize)) + {% endif %} + codecBuiltin.FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset, {{ param_name(codec.name)}}.{{ escape_keyword(param.name) }}) + {% if loop.last %} + {% if not should_add_begin_frame %} + initialFrame.flags |= BEGIN_DATA_STRUCTURE_FLAG + {% endif %} + clientMessage.AddFrame(initialFrame) + {% endif %} +{% endfor %} +{% for param in var_sized_params %} + {% if loop.first %} + + {% endif %} + {% if lang_types_encode(param.type) == '!skip' %} + {% continue %} + {% endif %} + {{ encode_var_sized(param) }} +{% endfor %} + +clientMessage.addFrame(END_FRAME.copy()); +} + +@Generated("!codec_hash!") +public final class {{ codec.name|capital }}Codec { + + +private {{ codec.name|capital }}Codec() { +} + +public static void encode(ClientMessage clientMessage, {{ lang_types_encode(codec.name) }} {{ param_name(codec.name) }}) { +{% if should_add_begin_frame %} + clientMessage.add(BEGIN_FRAME.copy()); + +{% endif %} +{% for param in fix_sized_params %} + {% if loop.first %} + ClientMessage.Frame initialFrame = new ClientMessage.Frame(new byte[INITIAL_FRAME_SIZE]); + {% endif %} + encode{{ param.type|capital }}(initialFrame.content, {{to_upper_snake_case(param.name)}}_FIELD_OFFSET, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}()); + {% if loop.last %} + {% if not should_add_begin_frame %} + initialFrame.flags |= BEGIN_DATA_STRUCTURE_FLAG; + {% endif %} + clientMessage.add(initialFrame); + + {% endif %} +{% endfor %} +{% for param in var_sized_params %} + {{ encode_var_sized(param) }}; + {% if loop.last %} + + {% endif %} +{% endfor %} +clientMessage.add(END_FRAME.copy()); +} + +public static {{ lang_types_decode(codec.name) }} decode(ClientMessage.ForwardFrameIterator iterator) { +// begin frame +{% if should_add_begin_frame %} + iterator.next(); + +{% endif %} +{% for param in fix_sized_params %} + {% if loop.first %} + ClientMessage.Frame initialFrame = iterator.next(); + {% endif %} + {% if param in fix_sized_new_params %} + boolean is{{ param.name|capital }}Exists = false; + {{ lang_types_decode(param.type) }} {{ param.name }} = {% if param.type == 'boolean' %}false{% elif param.type == 'UUID' %}null{% else %}0{% endif %}; + if (initialFrame.content.length >= {{ to_upper_snake_case(param.name) }}_FIELD_OFFSET + {{ param.type.upper() }}_SIZE_IN_BYTES) { + {{ param.name }} = decode{{ param.type|capital }}(initialFrame.content, {{ to_upper_snake_case(param.name) }}_FIELD_OFFSET); + is{{ param.name|capital }}Exists = true; + } + {% else %} + {{ lang_types_decode(param.type) }} {{ param.name }} = decode{{ param.type|capital }}(initialFrame.content, {{ to_upper_snake_case(param.name) }}_FIELD_OFFSET); + {% endif %} + {% if loop.last %} + + {% endif %} +{% endfor %} +{% for param in var_sized_params %} + {% if param in new_codec_params %} + boolean is{{ param.name|capital }}Exists = false; + {{ lang_types_decode(param.type) }} {{ param.name }} = null; + if (!iterator.peekNext().isEndFrame()) { + {{ param.name }} = {{ decode_var_sized(param) }}; + is{{ param.name|capital }}Exists = true; + } + {% else %} + {{ lang_types_decode(param.type) }} {{ param.name }} = {{ decode_var_sized(param) }}; + {% endif %} + {% if loop.last %} + + {% endif %} +{% endfor %} +fastForwardToEndFrame(iterator); + +{% if codec.returnWithFactory %} + return CustomTypeFactory.create{{ codec.name }}({% for param in codec.params %}{% if param in new_codec_params %}is{{ param.name|capital }}Exists, {% endif %}{{ param.name }}{% if not loop.last %}, {% endif %}{% endfor %}); +{% else %} + return new {{ lang_types_decode(codec.name) }}({% for param in codec.params %}{% if param in new_codec_params %}is{{ param.name|capital }}Exists, {% endif %}{{ param.name }}{% if not loop.last %}, {% endif %}{% endfor %}); +{% endif %} +} +} From 1dad2bc9482117c4c75c74cbf08fdc3ba58cf6cb Mon Sep 17 00:00:00 2001 From: Umit UNAL Date: Mon, 21 Dec 2020 10:37:36 +0300 Subject: [PATCH 03/41] first codec generated. --- go/__init__.py | 6 +- go/codec-template.go.j2 | 52 ++++++-------- go/custom-codec-template.go.j2 | 123 ++++++++++++--------------------- 3 files changed, 71 insertions(+), 110 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index 8adf54445..332d03b7a 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -27,9 +27,11 @@ def go_get_import_path_holders(param_type): class ImportPathHolder: - def __init__(self, name, path): + def __init__(self, name, path, is_builtin_codec=False, is_custom_codec=False): self.name = name self.path = path + self.is_builtin_codec = is_builtin_codec, + self.is_custom_codec = is_custom_codec def get_import_statement(self): return "from hazelcast.%s import %s" % (self.path, self.name) @@ -235,7 +237,7 @@ class PathHolders: "EntryList_Integer_UUID": "java.util.Collection>", "EntryList_Integer_Long": "java.util.Collection>", "EntryList_Integer_Integer": "java.util.Collection>", - "EntryList_UUID_Long": "java.util.Collection>", + "EntryList_UUID_Long": "map[core.UUID]int64", "EntryList_String_EntryList_Integer_Long": "java.util.Collection>>>", "EntryList_UUID_UUID": "java.util.Collection>", "EntryList_UUID_List_Integer": "java.util.Collection>>", diff --git a/go/codec-template.go.j2 b/go/codec-template.go.j2 index 977a1f096..7ae9f3865 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.go.j2 @@ -17,14 +17,14 @@ {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} codecBuiltin.ListMultiFrameCodec.DecodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type) %}_contains_nullable{% endif %}{% if param.nullable %}_nullable{% endif %}(frameIterator) {%- elif is_var_sized_entry_list(param.type) -%} - codecBuiltin.EntryListCodec.Decode{% if param.nullable %}Nullable{% endif %}(msg, {{ key_type(lang_name, param.type) }}Codec.decode, {{ value_type(lang_name, param.type) }}Codec.decode) + codecBuiltin.EntryListCodec.Decode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ key_type(lang_name, param.type) }}Codec.Decode, {{ value_type(lang_name, param.type) }}Codec.decode) {%- elif is_var_sized_map(param.type) -%} - codecBuiltin.MapCodec.Decode{% if param.nullable %}Nullable{% endif %}(msg, {{ key_type(lang_name, param.type) }}Codec.decode, {{ value_type(lang_name, param.type) }}Codec.decode) + codecBuiltin.MapCodec.Decode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ key_type(lang_name, param.type) }}Codec.Decode, {{ value_type(lang_name, param.type) }}Codec.decode) {%- else -%} {%- if param.nullable -%} - codecBuiltin.CodecUtil.DecodeNullable(msg, {{ lang_name(param.type) }}Codec.decode) + codecBuiltin.CodecUtil.DecodeNullable(clientMessage, {{ lang_name(param.type) }}Codec.Decode) {%- else -%} - codecBuiltin.{{ lang_name(param.type) }}Codec.Decode(msg) + codecBuiltin.{{ lang_name(param.type) }}Codec.Decode(clientMessage) {%- endif -%} {%- endif -%} {%- endmacro %} @@ -73,7 +73,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -package proto +package codec import ( "github.com/hazelcast/hazelcast-go-client/hazelcast/core" @@ -86,46 +86,38 @@ const( {{ service_name|capital }}{{ method.name|capital }}CodecRequestMessageType int32 = {{ method.request.id }} // hex: {{ '0x%06X'|format(method.response.id) }} {{ service_name|capital }}{{ method.name|capital }}CodecResponseMessageType int32 = {{ method.response.id }} + {% for event in method.events%} // hex: {{ '0x%06X'|format(event.id) }} {{ service_name|capital }}{{ method.name|capital }}CodecEvent{{ event.name|capital }}MessageType int32 = {{ event.id }} + {% endfor %} {#FIXED SIZED PARAMETER OFFSET CONSTANTS#} {% for param in request_fix_sized_params %} {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset = {% if loop.first %}protocol.PartitionIDOffset + protocol.IntSizeInBytes{% else %}protocol.Request{{ loop.previtem.name|capital }}Offset + protocol.{{ loop.previtem.type|capitalize }}SizeInBytes{% endif %} {% if loop.last %} - {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize = protocol.Request{{ param.name|capital }}Offset + protocol.{{ param.type|capitalize }}SizeInBytes + {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize = {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset + protocol.{{ param.type|capitalize }}SizeInBytes {% endif %} {% else %} {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize = protocol.PartitionIDOffset + protocol.IntSizeInBytes + {% endfor %} {% for param in response_fix_sized_params %} - {{ service_name|capital }}{{ method.name|capital }}Response{{ param.name|capital }}Offset = {% if loop.first %}protocol.ResponseBackupAcksOffset + protocol.ByteSizeInBytes{% else %}RESPONSE_{{ to_upper_snake_case(loop.previtem.name)}}_OFFSET + BitsUtil.{{loop.previtem.type.upper()}}_SIZE_IN_BYTES{% endif %} + {{ service_name|capital }}{{ method.name|capital }}Response{{ param.name|capital }}Offset = {% if loop.first %}protocol.ResponseBackupAcksOffset + protocol.ByteSizeInBytes{% else %}{{ service_name|capital }}{{ method.name|capital }}Response{{ loop.previtem.name|capital }}Offset + protocol.{{ loop.previtem.type|capitalize }}SizeInBytes{% endif %} + {% endfor %} {% for event in method.events %} {% for param in fixed_params(event.params) %} {{ service_name|capital }}{{ method.name|capital }}Event{{ event.name|capital }}{{param.name|capital}}Offset = {% if loop.first %}protocol.PartitionIDOffset + protocol.IntSizeInBytes{% else %}{{ service_name|capital }}{{ method.name|capital }}Event{{ event.name|capital }}{{ loop.previtem.name|capital }}Offset + protocol.{{loop.previtem.type|capitalize}}SizeInBytes{% endif %} + {% endfor %} {% endfor %} ) {#RESPONSE PARAMETERS#} {% set noResponseValue = method.response.params|length == 0 %} {% set singleResponseValue = method.response.params|length == 1 and response_new_params|length == 0 %} -{% if not (noResponseValue or singleResponseValue) %} - -/** @internal */ -type {{ service_name|capital }}{{ method.name|capital }}ResponseParams struct { -{% for param in method.response.params %} - {{ escape_keyword(param.name)|capital}} {{ lang_types_encode(param.type) }} -{% endfor %} -{% for new_param in response_new_params %} - is{{ new_param.name|capital }}Exists: boolean; -{% endfor %} -} -{% endif %} - {% for line in method.doc.splitlines() %} // {{ line }} @@ -134,7 +126,7 @@ type {{ service_name|lower }}{{ method.name|capital }}Codec struct {} var {{ service_name|capital }}{{ method.name|capital }}Codec {{ service_name|lower }}{{ method.name|capital }}Codec -func ({{ service_name|lower }}{{ method.name|capital }}Codec) Encode({% for param in method.request.params %}{{ escape_keyword(param.name) }} {{ lang_types_encode(param.type) }}{% if not loop.last %}, {% endif %}{% endfor %}) *protocol.ClientMessage { +func ({{ service_name|lower }}{{ method.name|capital }}Codec) EncodeRequest({% for param in method.request.params %}{{ escape_keyword(param.name) }} {{ lang_types_encode(param.type) }}{% if not loop.last %}, {% endif %}{% endfor %}) *protocol.ClientMessage { clientMessage := protocol.NewClientMessageForEncode() clientMessage.SetRetryable({{ method.request.retryable|lower }}) @@ -158,7 +150,7 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) Encode({% for para {% elif singleResponseValue %} {% set param = method.response.params|last %} -func ({{ service_name|lower }}{{ method.name|capital }}Codec) Decode(clientMessage protocol.ClientMessage) {{ lang_types_decode(param.type) }} { +func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeRequest(clientMessage *protocol.ClientMessage) {{ lang_types_decode(param.type) }} { frameIterator := clientMessage.FrameIterator() {% if response_fix_sized_params|length != 0 %} initialFrame := frameIterator.Next() @@ -176,25 +168,24 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) Decode(clientMessa } {% else %} -func ({{ service_name|lower }}{{ method.name|capital }}Codec) Decode() { {{ service_name|capital }}{{ method.name|capital }}ResponseParams { +func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeRequest(clientMessage *protocol.ClientMessage) ({% for param in method.response.params %}{{ escape_keyword(param.name)}} {{ lang_types_encode(param.type) }}{{ ", " if not loop.last }}{% endfor %} {% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists: boolean;{% endfor %}) { {% if response_fix_sized_params|length != 0 %} - const initialFrame = clientMessage.nextFrame() + initialFrame := clientMessage.FrameIterator().Next() {% else %} // empty initial frame - clientMessage.nextFrame() + clientMessage.FrameIterator().Next() {% endif %} -const response = {} as {{ service_name|capital }}{{ method.name|capital }}ResponseParams; {% for param in response_fix_sized_params %} {% if param in response_new_params %} if (initialFrame.content.length >= RESPONSE_{{ to_upper_snake_case(param.name) }}_OFFSET + BitsUtil.{{ param.type.upper() }}_SIZE_IN_BYTES) { - response.{{ escape_keyword(param.name) }} = FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.content, RESPONSE_{{to_upper_snake_case(param.name)}}_OFFSET); + response.{{ escape_keyword(param.name) }} = FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, RESPONSE_{{to_upper_snake_case(param.name)}}_OFFSET); response.is{{ param.name|capital }}Exists = true; } else { response.is{{ param.name|capital }}Exists = false; } {% else %} - response.{{ escape_keyword(param.name) }} = FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.content, RESPONSE_{{to_upper_snake_case(param.name)}}_OFFSET); + {{ escape_keyword(param.name) }} := FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, RESPONSE_{{to_upper_snake_case(param.name)}}_OFFSET) {% endif %} {% endfor %} {% for param in response_var_sized_params %} @@ -206,10 +197,11 @@ const response = {} as {{ service_name|capital }}{{ method.name|capital }}Respon response.is{{ param.name|capital }}Exists = false; } {% else %} - response.{{ escape_keyword(param.name) }} = {{ decode_var_sized(param) }}; + {{ escape_keyword(param.name) }} := {{ decode_var_sized(param) }} {% endif %} {% endfor %} -return response; + return {% for param in method.response.params %}{{ escape_keyword(param.name)}}{{ ", " if not loop.last }}{% endfor %} {% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists: boolean;{% endfor %} + } {% endif %} diff --git a/go/custom-codec-template.go.j2 b/go/custom-codec-template.go.j2 index 11b309112..4d3c2b06f 100644 --- a/go/custom-codec-template.go.j2 +++ b/go/custom-codec-template.go.j2 @@ -1,37 +1,37 @@ {% macro encode_var_sized(param) -%} {% if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - ListMultiFrameCodec.encode{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}(), {{ item_type(lang_name, param.type) }}Codec::encode) + codecBuiltin.ListMultiFrameCodec.Encode{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}(), {{ item_type(lang_name, param.type) }}Codec::encode) {%- elif is_var_sized_entry_list(param.type) -%} - EntryListCodec.encode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}(), {{ key_type(lang_name, param.type) }}Codec::encode, {{ value_type(lang_name, param.type) }}Codec::encodeNullable) + codecBuiltin.EntryListCodec.Encode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}(), {{ key_type(lang_name, param.type) }}Codec::encode, {{ value_type(lang_name, param.type) }}Codec::encodeNullable) {%- elif is_var_sized_map(param.type) -%} - MapCodec.encode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}(), {{ key_type(lang_name, param.type) }}Codec::encode, {{ value_type(lang_name, param.type) }}Codec::encode) + codecBuiltin.MapCodec.Encode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}(), {{ key_type(lang_name, param.type) }}Codec::encode, {{ value_type(lang_name, param.type) }}Codec::encode) {%- else -%} {%- if param.nullable -%} - CodecUtil.encodeNullable(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}(), {{ lang_name(param.type) }}Codec::encode) + codecBuiltin.CodecUtil.EncodeNullable(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}(), {{ lang_name(param.type) }}Codec::encode) {%- else -%} - {{ lang_name(param.type) }}Codec.Encode(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}()) + codecBuiltin.{{ lang_name(param.type) }}Codec.Encode(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}()) {%- endif %} {% endif %} {%- endmacro %} {% macro decode_var_sized(param) -%} {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - ListMultiFrameCodec.decode{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(iterator, {{ item_type(lang_name, param.type) }}Codec::decode) + codecBuiltin.ListMultiFrameCodec.Decode{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(iterator, {{ item_type(lang_name, param.type) }}Codec::decode) {%- elif is_var_sized_entry_list(param.type) -%} - EntryListCodec.decode{% if param.nullable %}Nullable{% endif %}(iterator, {{ key_type(lang_name, param.type) }}Codec::decode, {{ value_type(lang_name, param.type) }}Codec::decodeNullable) + codecBuiltin.EntryListCodec.Decode{% if param.nullable %}Nullable{% endif %}(frameIterator, {{ key_type(lang_name, param.type) }}Codec::decode, {{ value_type(lang_name, param.type) }}Codec::DecodeNullable) {%- elif is_var_sized_map(param.type) -%} - MapCodec.decode{% if param.nullable %}Nullable{% endif %}(iterator, {{ key_type(lang_name, param.type) }}Codec::decode, {{ value_type(lang_name, param.type) }}Codec::decode) + codecBuiltin.MapCodec.Decode{% if param.nullable %}Nullable{% endif %}(frameIterator, {{ key_type(lang_name, param.type) }}Codec::decode, {{ value_type(lang_name, param.type) }}Codec::decode) {%- else -%} {%- if param.nullable -%} - CodecUtil.decodeNullable(iterator, {{ lang_name(param.type) }}Codec::decode) + codecBuiltin.CodecUtil.DecodeNullable(frameIterator, {{ lang_name(param.type) }}Codec::decode) {%- else -%} - {{ lang_name(param.type) }}Codec.decode(iterator) + codecBuiltin.{{ lang_name(param.type) }}Codec.Decode(frameIterator) {%- endif -%} {%- endif -%} {%- endmacro %} /* * Copyright (c) 2008-2020, Hazelcast, Inc. All Rights Reserved. * -* Licensed under the Apache License, Version 2.0 (the "License"); +* Licensed under the Apache License, Version 2.0 (the "License") * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * @@ -63,7 +63,7 @@ const( {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset = {% if loop.first %}0{% else %}{{ to_upper_snake_case(loop.previtem.name)}}_FIELD_OFFSET + {{ loop.previtem.type.upper() }}_SIZE_IN_BYTES{% endif %} {% if loop.last %} - {{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize = {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset + protocol.{{ param.type }}SizeInBytes; + {{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize = {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset + protocol.{{ param.type }}SizeInBytes {% endif %} {% endfor %} ) @@ -72,7 +72,7 @@ type {{ codec.name|lower }}Codec struct {} var {{ codec.name|capital }}Codec {{ codec.name|lower }}Codec -func ({{ codec.name|lower }}Codec) Encode(clientMessage protocol.ClientMessage, {{ param_name(codec.name) }} {{ lang_types_encode(codec.name) }}){ +func ({{ codec.name|lower }}Codec) Encode(clientMessage *protocol.ClientMessage, {{ param_name(codec.name) }} {{ lang_types_encode(codec.name) }}){ {% if should_add_begin_frame %} clientMessage.AddFrame(protocol.BeginFrame.Copy()) @@ -99,88 +99,55 @@ func ({{ codec.name|lower }}Codec) Encode(clientMessage protocol.ClientMessage, {{ encode_var_sized(param) }} {% endfor %} -clientMessage.addFrame(END_FRAME.copy()); + clientMessage.AddFrame(protocol.EndFrame.Copy()) } -@Generated("!codec_hash!") -public final class {{ codec.name|capital }}Codec { - - -private {{ codec.name|capital }}Codec() { -} - -public static void encode(ClientMessage clientMessage, {{ lang_types_encode(codec.name) }} {{ param_name(codec.name) }}) { -{% if should_add_begin_frame %} - clientMessage.add(BEGIN_FRAME.copy()); - -{% endif %} -{% for param in fix_sized_params %} - {% if loop.first %} - ClientMessage.Frame initialFrame = new ClientMessage.Frame(new byte[INITIAL_FRAME_SIZE]); - {% endif %} - encode{{ param.type|capital }}(initialFrame.content, {{to_upper_snake_case(param.name)}}_FIELD_OFFSET, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}()); - {% if loop.last %} - {% if not should_add_begin_frame %} - initialFrame.flags |= BEGIN_DATA_STRUCTURE_FLAG; - {% endif %} - clientMessage.add(initialFrame); - - {% endif %} -{% endfor %} -{% for param in var_sized_params %} - {{ encode_var_sized(param) }}; - {% if loop.last %} - - {% endif %} -{% endfor %} -clientMessage.add(END_FRAME.copy()); -} - -public static {{ lang_types_decode(codec.name) }} decode(ClientMessage.ForwardFrameIterator iterator) { +func ({{ codec.name|lower }}Codec) Decode(frameIterator *protocol.ForwardFrameIterator) { // begin frame {% if should_add_begin_frame %} - iterator.next(); - + frameIterator.Next() {% endif %} {% for param in fix_sized_params %} {% if loop.first %} - ClientMessage.Frame initialFrame = iterator.next(); + initialFrame := frameIterator.Next() {% endif %} {% if param in fix_sized_new_params %} - boolean is{{ param.name|capital }}Exists = false; - {{ lang_types_decode(param.type) }} {{ param.name }} = {% if param.type == 'boolean' %}false{% elif param.type == 'UUID' %}null{% else %}0{% endif %}; - if (initialFrame.content.length >= {{ to_upper_snake_case(param.name) }}_FIELD_OFFSET + {{ param.type.upper() }}_SIZE_IN_BYTES) { - {{ param.name }} = decode{{ param.type|capital }}(initialFrame.content, {{ to_upper_snake_case(param.name) }}_FIELD_OFFSET); - is{{ param.name|capital }}Exists = true; - } + is{{ param.name|capital }}Exists := false + let {{ escape_keyword(param.name) }} = {% if param.type == 'boolean' %}false{% elif param.type == 'UUID' %}null{% else %}0{% endif %} + if (initialFrame.content.length >= {{ to_upper_snake_case(param.name) }}_OFFSET + BitsUtil.{{ param.type.upper() }}_SIZE_IN_BYTES) { + {{ escape_keyword(param.name) }} = codecBuiltin.FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ to_upper_snake_case(param.name) }}_OFFSET) + is{{ param.name|capital }}Exists = true + } {% else %} - {{ lang_types_decode(param.type) }} {{ param.name }} = decode{{ param.type|capital }}(initialFrame.content, {{ to_upper_snake_case(param.name) }}_FIELD_OFFSET); - {% endif %} - {% if loop.last %} - + {{ escape_keyword(param.name) }} := codecBuiltin.FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset) {% endif %} {% endfor %} {% for param in var_sized_params %} + {% if loop.first %} + + {% endif %} + {% if lang_types_decode(param.type) == '!skip' %} + {% continue %} + {% endif %} {% if param in new_codec_params %} - boolean is{{ param.name|capital }}Exists = false; - {{ lang_types_decode(param.type) }} {{ param.name }} = null; - if (!iterator.peekNext().isEndFrame()) { - {{ param.name }} = {{ decode_var_sized(param) }}; - is{{ param.name|capital }}Exists = true; - } + is{{ param.name|capital }}Exists = false + {{ escape_keyword(param.name) }} = null + if (!clientMessage.peekNextFrame().isEndFrame()) { + {{ escape_keyword(param.name) }} := {{ decode_var_sized(param) }} + is{{ param.name|capital }}Exists := true + } {% else %} - {{ lang_types_decode(param.type) }} {{ param.name }} = {{ decode_var_sized(param) }}; + {{ escape_keyword(param.name) }} := {{ decode_var_sized(param) }} {% endif %} - {% if loop.last %} +{% endfor %} + codecBuiltin.CodecUtil.FastForwardToEndFrame(frameIterator) + +{% set ctor_params = [] %} +{% for param in codec.params %} + {% if lang_types_decode(param.type) != '!skip' %} + {% do ctor_params.append(param) %} {% endif %} {% endfor %} -fastForwardToEndFrame(iterator); - -{% if codec.returnWithFactory %} - return CustomTypeFactory.create{{ codec.name }}({% for param in codec.params %}{% if param in new_codec_params %}is{{ param.name|capital }}Exists, {% endif %}{{ param.name }}{% if not loop.last %}, {% endif %}{% endfor %}); -{% else %} - return new {{ lang_types_decode(codec.name) }}({% for param in codec.params %}{% if param in new_codec_params %}is{{ param.name|capital }}Exists, {% endif %}{{ param.name }}{% if not loop.last %}, {% endif %}{% endfor %}); -{% endif %} -} + return core.New{{ codec.name }}({% for param in ctor_params %}{% if param in new_codec_params %}is{{ param.name|capital }}Exists, {% endif %}{{ escape_keyword(param.name) }}{% if not loop.last %}, {% endif %}{% endfor %}) } From 5d2f1425fdbf9df8073fbc83d7611dcdcab081e4 Mon Sep 17 00:00:00 2001 From: Umit UNAL Date: Mon, 21 Dec 2020 11:00:44 +0300 Subject: [PATCH 04/41] first codec generated. --- go/custom-codec-template.go.j2 | 2 +- util.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/go/custom-codec-template.go.j2 b/go/custom-codec-template.go.j2 index 4d3c2b06f..b2476d84d 100644 --- a/go/custom-codec-template.go.j2 +++ b/go/custom-codec-template.go.j2 @@ -44,7 +44,7 @@ * limitations under the License. */ -package proto +package custom import ( "github.com/hazelcast/hazelcast-go-client/hazelcast/core" diff --git a/util.py b/util.py index ae47a808d..0c3c673bc 100644 --- a/util.py +++ b/util.py @@ -395,7 +395,7 @@ class SupportedLanguages(Enum): SupportedLanguages.CS: 'src/Hazelcast.Net/Protocol/CustomCodecs/', SupportedLanguages.PY: 'hazelcast/protocol/codec/custom/', SupportedLanguages.TS: 'src/codec/custom', - SupportedLanguages.GO: 'internal/proto/' + SupportedLanguages.GO: 'internal/custom/' } From 705d033af1c73e127fe01a9941e6cc39ed0a551e Mon Sep 17 00:00:00 2001 From: Umit UNAL Date: Mon, 21 Dec 2020 21:11:24 +0300 Subject: [PATCH 05/41] first codec generated. --- go/__init__.py | 320 +++++++++++++++++++++------------------- go/codec-template.go.j2 | 27 ++-- util.py | 4 +- 3 files changed, 184 insertions(+), 167 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index 332d03b7a..90cc03120 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -10,16 +10,22 @@ def go_types_encode(key): try: - return _go_types_encode[key] + go_type = _go_types_encode[key] except KeyError: - return _go_types_common[key] + go_type = _go_types_common[key] + if go_type == "NA": + raise NotImplementedError("Missing type mapping for '" + key + "'") + return go_type def go_types_decode(key): try: - return _go_types_decode[key] + go_type = _go_types_decode[key] except KeyError: - return _go_types_common[key] + go_type = _go_types_common[key] + if go_type == "NA": + raise NotImplementedError("Missing type for '" + key + "'") + return go_type def go_get_import_path_holders(param_type): @@ -30,73 +36,90 @@ class ImportPathHolder: def __init__(self, name, path, is_builtin_codec=False, is_custom_codec=False): self.name = name self.path = path - self.is_builtin_codec = is_builtin_codec, + self.is_builtin_codec = is_builtin_codec self.is_custom_codec = is_custom_codec def get_import_statement(self): - return "from hazelcast.%s import %s" % (self.path, self.name) + if self.is_custom_codec: + return "codecCustom \"github.com/hazelcast/hazelcast-go-client/hazelcast%s\"" % self.path + if self.is_builtin_codec: + return "codecBuiltin \"github.com/hazelcast/hazelcast-go-client/hazelcast%s\"" % self.path + return "\"github.com/hazelcast/hazelcast-go-client/hazelcast%s\"" % self.path class PathHolders: - DataCodec = ImportPathHolder("DataCodec", "protocol.builtin") - ByteArrayCodec = ImportPathHolder("ByteArrayCodec", "protocol.builtin") - LongArrayCodec = ImportPathHolder("LongArrayCodec", "protocol.builtin") - Address = ImportPathHolder("Address", "core") - AddressCodec = ImportPathHolder("AddressCodec", "protocol.codec.custom.address_codec") - ErrorHolder = ImportPathHolder("ErrorHolder", "protocol") - ErrorHolderCodec = ImportPathHolder("ErrorHolderCodec", "protocol.codec.custom.error_holder_codec") - StackTraceElement = ImportPathHolder("StackTraceElement", "protocol") + UUID = ImportPathHolder('UUID', '/core') + Data = ImportPathHolder('Data', '/internal/protocol/serialization', is_builtin_codec=False, is_custom_codec=False) + DataCodec = ImportPathHolder("DataCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) + ByteArrayCodec = ImportPathHolder("ByteArrayCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) + LongArrayCodec = ImportPathHolder("LongArrayCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) + Address = ImportPathHolder("Address", "/core") + AddressCodec = ImportPathHolder("AddressCodec", "/internal/protocol/codec/custom", is_custom_codec=True) + ErrorHolder = ImportPathHolder("ErrorHolder", "/internal/protocol") + ErrorHolderCodec = ImportPathHolder("ErrorHolderCodec", "/internal/protocol/codec/custom", is_custom_codec=True) + StackTraceElement = ImportPathHolder("StackTraceElement", "/internal/protocol") StackTraceElementCodec = ImportPathHolder("StackTraceElementCodec", - "protocol.codec.custom.stack_trace_element_codec") - SimpleEntryView = ImportPathHolder("SimpleEntryView", "core") - SimpleEntryViewCodec = ImportPathHolder("SimpleEntryViewCodec", "protocol.codec.custom.simple_entry_view_codec") - DistributedObjectInfo = ImportPathHolder("DistributedObjectInfo", "core") - DistributedObjectInfoCodec = ImportPathHolder("DistributedObjectInfoCodec", - "protocol.codec.custom.distributed_object_info_codec") - MemberInfo = ImportPathHolder("MemberInfo", "core") - MemberInfoCodec = ImportPathHolder("MemberInfoCodec", "protocol.codec.custom.member_info_codec") - MemberVersion = ImportPathHolder("MemberVersion", "core") - MemberVersionCodec = ImportPathHolder("MemberVersionCodec", "protocol.codec.custom.member_version_codec") - StringCodec = ImportPathHolder("StringCodec", "protocol.builtin", ) - ListLongCodec = ImportPathHolder("ListLongCodec", "protocol.builtin") - ListIntegerCodec = ImportPathHolder("ListIntegerCodec", "protocol.builtin") - ListUUIDCodec = ImportPathHolder("ListUUIDCodec", "protocol.builtin") - ListDataCodec = ImportPathHolder("ListDataCodec", "protocol.builtin") - ListMultiFrameCodec = ImportPathHolder("ListMultiFrameCodec", "protocol.builtin") - EntryListCodec = ImportPathHolder("EntryListCodec", "protocol.builtin") - EntryListLongByteArrayCodec = ImportPathHolder("EntryListLongByteArrayCodec", "protocol.builtin") - EntryListIntegerUUIDCodec = ImportPathHolder("EntryListIntegerUUIDCodec", "protocol.builtin") - EntryListIntegerLongCodec = ImportPathHolder("EntryListIntegerLongCodec", "protocol.builtin") - EntryListIntegerIntegerCodec = ImportPathHolder("EntryListIntegerIntegerCodec", "protocol.builtin") - EntryListUUIDLongCodec = ImportPathHolder("EntryListUUIDLongCodec", "protocol.builtin") - EntryListUUIDUUIDCodec = ImportPathHolder("EntryListUUIDUUIDCodec", "protocol.builtin") - EntryListUUIDListIntegerCodec = ImportPathHolder("EntryListUUIDListIntegerCodec", "protocol.builtin") - MapCodec = ImportPathHolder("MapCodec", "protocol.builtin") - CodecUtil = ImportPathHolder("CodecUtil", "protocol.builtin") - IndexConfig = ImportPathHolder("IndexConfig", "config") - IndexConfigCodec = ImportPathHolder("IndexConfigCodec", "protocol.codec.custom.index_config_codec") - BitmapIndexOptions = ImportPathHolder("BitmapIndexOptions", "config") - BitmapIndexOptionsCodec = ImportPathHolder("BitmapIndexOptionsCodec", - "protocol.codec.custom.bitmap_index_options_codec") - PagingPredicateHolder = ImportPathHolder("PagingPredicateHolder", "protocol") - PagingPredicateHolderCodec = ImportPathHolder("PagingPredicateHolderCodec", - "protocol.codec.custom.paging_predicate_holder_codec") - AnchorDataListHolder = ImportPathHolder("AnchorDataListHolder", "protocol") - AnchorDataListHolderCodec = ImportPathHolder("AnchorDataListHolderCodec", - "protocol.codec.custom.anchor_data_list_holder_codec") - EndpointQualifier = ImportPathHolder("EndpointQualifier", "protocol") - EndpointQualifierCodec = ImportPathHolder("EndpointQualifierCodec", - "protocol.codec.custom.endpoint_qualifier_codec") - RaftGroupId = ImportPathHolder("RaftGroupId", "protocol") - RaftGroupIdCodec = ImportPathHolder("RaftGroupIdCodec", "protocol.codec.custom.raft_group_id_codec") + "/internal/protocol/codec/custom", is_custom_codec=True) + SimpleEntryView = ImportPathHolder("SimpleEntryView", "/core") + SimpleEntryViewCodec = ImportPathHolder("SimpleEntryViewCodec", "/internal/protocol/codec/custom", + is_custom_codec=True) + DistributedObjectInfo = ImportPathHolder("DistributedObjectInfo", "/core") + DistributedObjectInfoCodec = ImportPathHolder("DistributedObjectInfoCodec", "/internal/protocol/codec/custom", + is_custom_codec=True) + MemberInfo = ImportPathHolder("MemberInfo", "/core") + MemberInfoCodec = ImportPathHolder("MemberInfoCodec", "/internal/protocol/codec/custom", is_custom_codec=True) + MemberVersion = ImportPathHolder("MemberVersion", "/core") + MemberVersionCodec = ImportPathHolder("MemberVersionCodec", "/internal/protocol/codec/custom", is_custom_codec=True) + StringCodec = ImportPathHolder("StringCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) + ListLongCodec = ImportPathHolder("ListLongCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) + ListIntegerCodec = ImportPathHolder("ListIntegerCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) + ListUUIDCodec = ImportPathHolder("ListUUIDCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) + ListDataCodec = ImportPathHolder("ListDataCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) + ListMultiFrameCodec = ImportPathHolder("ListMultiFrameCodec", "/internal/protocol/codec/builtin", + is_builtin_codec=True) + EntryListCodec = ImportPathHolder("EntryListCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) + EntryListLongByteArrayCodec = ImportPathHolder("EntryListLongByteArrayCodec", "/internal/protocol/codec/builtin", + is_builtin_codec=True) + EntryListIntegerUUIDCodec = ImportPathHolder("EntryListIntegerUUIDCodec", "/internal/protocol/codec/builtin", + is_builtin_codec=True) + EntryListIntegerLongCodec = ImportPathHolder("EntryListIntegerLongCodec", "/internal/protocol/codec/builtin", + is_builtin_codec=True) + EntryListIntegerIntegerCodec = ImportPathHolder("EntryListIntegerIntegerCodec", "/internal/protocol/codec/builtin", + is_builtin_codec=True) + EntryListUUIDLongCodec = ImportPathHolder("EntryListUUIDLongCodec", "/internal/protocol/codec/builtin", + is_builtin_codec=True) + EntryListUUIDUUIDCodec = ImportPathHolder("EntryListUUIDUUIDCodec", "/internal/protocol/codec/builtin", + is_builtin_codec=True) + EntryListUUIDListIntegerCodec = ImportPathHolder("EntryListUUIDListIntegerCodec", + "/internal/protocol/codec/builtin", + is_builtin_codec=True) + MapCodec = ImportPathHolder("MapCodec", "/internal/protocol/codec/builtin", + is_builtin_codec=True) + CodecUtilCodec = ImportPathHolder("CodecUtil", "/internal/protocol/codec/builtin", + is_builtin_codec=True) + IndexConfig = ImportPathHolder("IndexConfig", "/core") + IndexConfigCodec = ImportPathHolder("IndexConfigCodec", "/internal/protocol/codec/custom", is_custom_codec=True) + BitmapIndexOptions = ImportPathHolder("BitmapIndexOptions", "/core") + BitmapIndexOptionsCodec = ImportPathHolder("BitmapIndexOptionsCodec", "/internal/protocol/codec/custom", + is_custom_codec=True) + PagingPredicateHolder = ImportPathHolder("PagingPredicateHolder", "/core") + PagingPredicateHolderCodec = ImportPathHolder("PagingPredicateHolderCodec", "/internal/protocol/codec/custom", + is_custom_codec=True) + AnchorDataListHolder = ImportPathHolder("AnchorDataListHolder", "/core") + AnchorDataListHolderCodec = ImportPathHolder("AnchorDataListHolderCodec", "/internal/protocol/codec/custom", + is_custom_codec=True) + RaftGroupId = ImportPathHolder("RaftGroupId", "/core", is_builtin_codec=False, is_custom_codec=False) + RaftGroupIdCodec = ImportPathHolder("RaftGroupIdCodec", "/internal/protocol/codec/custom", + is_custom_codec=True) import_paths = { - "CodecUtil": PathHolders.CodecUtil, + "UUID": [PathHolders.UUID], + "CodecUtil": PathHolders.CodecUtilCodec, "longArray": [PathHolders.LongArrayCodec], "byteArray": [PathHolders.ByteArrayCodec], "String": [PathHolders.StringCodec], - "Data": [PathHolders.DataCodec], + "Data": [PathHolders.Data, PathHolders.DataCodec], "Address": [PathHolders.Address, PathHolders.AddressCodec], "ErrorHolder": [PathHolders.ErrorHolder, PathHolders.ErrorHolderCodec], "StackTraceElement": [PathHolders.StackTraceElement, PathHolders.StackTraceElementCodec], @@ -133,9 +156,6 @@ class PathHolders: "BitmapIndexOptions": [PathHolders.BitmapIndexOptions, PathHolders.BitmapIndexOptionsCodec], "AnchorDataListHolder": [PathHolders.AnchorDataListHolder, PathHolders.AnchorDataListHolderCodec], "PagingPredicateHolder": [PathHolders.PagingPredicateHolder, PathHolders.PagingPredicateHolderCodec], - "EndpointQualifier": [PathHolders.EndpointQualifier, PathHolders.EndpointQualifierCodec], - "Map_EndpointQualifier_Address": [PathHolders.MapCodec, PathHolders.EndpointQualifierCodec, - PathHolders.AddressCodec] } _go_types_common = { @@ -153,10 +173,10 @@ class PathHolders: "Data": "serialization.Data", "Address": "core.Address", - "ErrorHolder": "com.hazelcast.client.impl.protocol.exception.ErrorHolder", - "StackTraceElement": "StackTraceElement", + "ErrorHolder": "core.ErrorHolder", + "StackTraceElement": "core.StackTraceElement", "SimpleEntryView": "Pair", - "RaftGroupId": "NA", + "RaftGroupId": "core.RaftGroupId", "WanReplicationRef": "NA", "HotRestartConfig": "NA", "EventJournalConfig": "NA", @@ -175,16 +195,16 @@ class PathHolders: "CacheEventData": "NA", "QueryCacheConfigHolder": "NA", "MapStoreConfigHolder": "NA", - "DistributedObjectInfo": "NA", - "IndexConfig": "NA", - "BitmapIndexOptions": "NA", + "DistributedObjectInfo": "core.DistributedObjectInfo", + "IndexConfig": "core.IndexConfig", + "BitmapIndexOptions": "core.BitmapIndexOptions", "AttributeConfig": "NA", "ListenerConfigHolder": "NA", "CacheSimpleEntryListenerConfig": "NA", "ClientBwListEntry": "NA", "EndpointQualifier": "NA", - "Map_String_String": "NA", + "Map_String_String": "map[string]string", "Map_EndpointQualifier_Address": "NA", "List_CPMember": "NA" @@ -199,103 +219,103 @@ class PathHolders: "MemberInfo": "NA", "MemberVersion": "NA", "MCEvent": "NA", - "AnchorDataListHolder": "NA", - "PagingPredicateHolder": "NA", + "AnchorDataListHolder": "AnchorDataListHolder", + "PagingPredicateHolder": "PagingPredicateHolder", "SqlQueryId": "NA", "SqlError": "NA", "SqlColumnMetadata": "NA", "CPMember": "NA", "MigrationState": "NA", - "List_Long": "java.util.Collection", - "List_Integer": "java.util.Collection", - "List_UUID": "java.util.Collection", + "List_Long": "[]int64", + "List_Integer": "[]int32", + "List_UUID": "[]core.UUID", "List_String": "[]string", - "List_Xid": "java.util.Collection", + "List_Xid": "NA", "List_Data": "[]serialization.Data", - "List_List_Data": "java.util.Collection>", - "ListCN_Data": "java.util.Collection", - "List_ListCN_Data": "java.util.Collection>", - "List_MemberInfo": "java.util.Collection", - "List_ScheduledTaskHandler": "java.util.Collection", - "List_CacheEventData": "java.util.Collection", - "List_QueryCacheConfigHolder": "java.util.Collection", - "List_DistributedObjectInfo": "java.util.Collection", - "List_QueryCacheEventData": "java.util.Collection", - "List_IndexConfig": "java.util.Collection", - "List_AttributeConfig": "java.util.Collection", - "List_ListenerConfigHolder": "java.util.Collection", - "List_CacheSimpleEntryListenerConfig": "java.util.Collection", - "List_StackTraceElement": "java.util.Collection", - "List_ClientBwListEntry": "java.util.Collection", - "List_MCEvent": "java.util.Collection", - "List_SqlColumnMetadata": "java.util.List", + "List_List_Data": "[]serialization.Data", + "ListCN_Data": "[]serialization.Data", + "List_ListCN_Data": "NA", + "List_MemberInfo": "[]MemberInfo", + "List_ScheduledTaskHandler": "NA", + "List_CacheEventData": "NA", + "List_QueryCacheConfigHolder": "NA", + "List_DistributedObjectInfo": "[]DistributedObjectInfo", + "List_QueryCacheEventData": "NA", + "List_IndexConfig": "[]IndexConfig", + "List_AttributeConfig": "NA", + "List_ListenerConfigHolder": "NA", + "List_CacheSimpleEntryListenerConfig": "NA", + "List_StackTraceElement": "[]StackTraceElement", + "List_ClientBwListEntry": "NA", + "List_MCEvent": "NA", + "List_SqlColumnMetadata": "NA", - "EntryList_String_String": "java.util.Collection>", - "EntryList_String_byteArray": "java.util.Collection>", - "EntryList_Long_byteArray": "java.util.Collection>", - "EntryList_Integer_UUID": "java.util.Collection>", - "EntryList_Integer_Long": "java.util.Collection>", - "EntryList_Integer_Integer": "java.util.Collection>", - "EntryList_UUID_Long": "map[core.UUID]int64", - "EntryList_String_EntryList_Integer_Long": "java.util.Collection>>>", - "EntryList_UUID_UUID": "java.util.Collection>", - "EntryList_UUID_List_Integer": "java.util.Collection>>", - "EntryList_Data_Data": "java.util.Collection>", - "EntryList_Data_List_Data": "java.util.Collection>>", + "EntryList_String_String": "[]Pair", + "EntryList_String_byteArray": "[]Pair", + "EntryList_Long_byteArray": "[]Pair", + "EntryList_Integer_UUID": "[]Pair", + "EntryList_Integer_Long": "[]Pair", + "EntryList_Integer_Integer": "[]Pair", + "EntryList_UUID_Long": "[]Pair", + "EntryList_String_EntryList_Integer_Long": "[]Pair", + "EntryList_UUID_UUID": "[]Pair", + "EntryList_UUID_List_Integer": "[]Pair", + "EntryList_Data_Data": "[]Pair", + "EntryList_Data_List_Data": "[]Pair", } _go_types_decode = { - "CacheEventData": "com.hazelcast.cache.impl.CacheEventDataImpl", - "QueryCacheEventData": "com.hazelcast.map.impl.querycache.event.DefaultQueryCacheEventData", - "ScheduledTaskHandler": "com.hazelcast.scheduledexecutor.impl.ScheduledTaskHandlerImpl", - "Xid": "com.hazelcast.transaction.impl.xa.SerializableXID", - "ClientBwListEntry": "com.hazelcast.internal.management.dto.ClientBwListEntryDTO", - "MemberInfo": "com.hazelcast.internal.cluster.MemberInfo", - "MemberVersion": "com.hazelcast.version.MemberVersion", - "MCEvent": "com.hazelcast.internal.management.dto.MCEventDTO", - "AnchorDataListHolder": "com.hazelcast.client.impl.protocol.codec.holder.AnchorDataListHolder", - "PagingPredicateHolder": "com.hazelcast.client.impl.protocol.codec.holder.PagingPredicateHolder", - "SqlQueryId": "com.hazelcast.sql.impl.QueryId", - "SqlError": "com.hazelcast.sql.impl.client.SqlError", - "SqlColumnMetadata": "com.hazelcast.sql.SqlColumnMetadata", - "CPMember": "com.hazelcast.cp.internal.CPMemberInfo", - "MigrationState": "com.hazelcast.internal.partition.MigrationStateImpl", + "CacheEventData": "NA", + "QueryCacheEventData": "NA", + "ScheduledTaskHandler": "NA", + "Xid": "NA", + "ClientBwListEntry": "NA", + "MemberInfo": "MemberInfo", + "MemberVersion": "MemberVersion", + "MCEvent": "NA", + "AnchorDataListHolder": "AnchorDataListHolder", + "PagingPredicateHolder": "PagingPredicateHolder", + "SqlQueryId": "NA", + "SqlError": "NA", + "SqlColumnMetadata": "NA", + "CPMember": "NA", - "List_Long": "java.util.List", - "List_Integer": "java.util.List", - "List_UUID": "java.util.List", - "List_Xid": "java.util.List", + "List_Long": "[]int64", + "List_Integer": "[]int32", + "List_UUID": "[]core.UUID", + "List_Xid": "NA", "List_String": "[]string", "List_Data": "[]serialization.Data", - "List_List_Data": "java.util.List>", - "ListCN_Data": "java.util.List", - "List_ListCN_Data": "java.util.List>", - "List_MemberInfo": "java.util.List", - "List_CacheEventData": "java.util.List", - "List_QueryCacheConfigHolder": "java.util.List", + "List_List_Data": "[]serialization.Data", + "ListCN_Data": "[]serialization.Data", + "List_ListCN_Data": "NA", + "List_MemberInfo": "[]MemberInfo", + "List_CacheEventData": "NA", + "List_QueryCacheConfigHolder": "NA", "List_DistributedObjectInfo": "[]core.DistributedObjectInfo", - "List_QueryCacheEventData": "java.util.List", - "List_IndexConfig": "java.util.List", - "List_AttributeConfig": "java.util.List", - "List_ListenerConfigHolder": "java.util.List", - "List_CacheSimpleEntryListenerConfig": "java.util.List", - "List_StackTraceElement": "java.util.List", - "List_ClientBwListEntry": "java.util.List", - "List_MCEvent": "java.util.List", - "List_ScheduledTaskHandler": "java.util.Collection", - "List_SqlColumnMetadata": "java.util.List", + "List_QueryCacheEventData": "NA", + "List_IndexConfig": "[]IndexConfig", + "List_AttributeConfig": "NA", + "List_ListenerConfigHolder": "NA", + "List_CacheSimpleEntryListenerConfig": "NA", + "List_StackTraceElement": "[]StackTraceElement", + "List_ClientBwListEntry": "NA", + "List_MCEvent": "NA", + "List_ScheduledTaskHandler": "NA", + "List_SqlColumnMetadata": "NA", + "List_CPMember": "NA", - "EntryList_String_String": "java.util.List>", - "EntryList_String_byteArray": "java.util.List>", - "EntryList_Long_byteArray": "java.util.List>", - "EntryList_Integer_UUID": "java.util.List>", - "EntryList_Integer_Long": "java.util.List>", - "EntryList_Integer_Integer": "java.util.List>", - "EntryList_UUID_Long": "java.util.List>", - "EntryList_String_EntryList_Integer_Long": "java.util.List>>>", - "EntryList_UUID_UUID": "java.util.List>", - "EntryList_UUID_List_Integer": "java.util.List>>", - "EntryList_Data_Data": "java.util.List>", - "EntryList_Data_List_Data": "java.util.List>>", + "EntryList_String_String": "[]Pair", + "EntryList_String_byteArray": "[]Pair", + "EntryList_Long_byteArray": "[]Pair", + "EntryList_Integer_UUID": "[]Pair", + "EntryList_Integer_Long": "[]Pair", + "EntryList_Integer_Integer": "[]Pair", + "EntryList_UUID_Long": "[]Pair", + "EntryList_String_EntryList_Integer_Long": "[]Pair", + "EntryList_UUID_UUID": "[]Pair", + "EntryList_UUID_List_Integer": "[]Pair", + "EntryList_Data_Data": "[]Pair", + "EntryList_Data_List_Data": "[]Pair", } diff --git a/go/codec-template.go.j2 b/go/codec-template.go.j2 index 7ae9f3865..989ba9518 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.go.j2 @@ -10,6 +10,7 @@ codecBuiltin.CodecUtil.EncodeNullable(clientMessage, {{ param_name(param.name) }}, {{ lang_name(param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) {%- else -%} codecBuiltin.{{ lang_name(param.type) }}Codec.Encode(clientMessage, {{ param_name(param.name) }}{% if loop_last %}, True{% endif %}) + {{ lang_types_decode(param.type) }} {%- endif %} {% endif %} {%- endmacro %} @@ -28,20 +29,19 @@ {%- endif -%} {%- endif -%} {%- endmacro %} + {% macro get_import_statements() -%} {% set imported_paths = [] %} {%- for params in varargs -%} {% for param in params %} {% set path_holders = get_import_path_holders(param.type) %} - {%- for path_holder in path_holders -%} - {% if not path_holder.name in imported_paths and path_holder.name.endswith('Codec') %} - {%- do imported_paths.append(path_holder.name) -%} - {{ path_holder.get_import_statement() }} - {% endif %} - {% endfor %} - {% if not (is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) or is_var_sized_entry_list(param.type) or is_var_sized_map(param.type)) and param.nullable and param.type != 'UUID' and not 'CodecUtil' in imported_paths %} - {%- do imported_paths.append('CodecUtil') -%} - {{ get_import_path_holders('CodecUtil').get_import_statement() }} + {% if path_holders is not none %} + {%- for path_holder in path_holders -%} + {% if not path_holder.path in imported_paths%} + {%- do imported_paths.append(path_holder.path) -%} + {{ path_holder.get_import_statement() }} + {% endif %} + {% endfor %} {% endif %} {%- endfor -%} {%- endfor -%} @@ -76,10 +76,7 @@ package codec import ( - "github.com/hazelcast/hazelcast-go-client/hazelcast/core" - "github.com/hazelcast/hazelcast-go-client/hazelcast/internal/protocol" - codecBuiltin "github.com/hazelcast/hazelcast-go-client/hazelcast/internal/protocol/codec/builtin" -) +{{get_import_statements(request_fix_sized_params, request_var_sized_params, response_fix_sized_params, response_var_sized_params, event_fix_sized_params, event_var_sized_params)|indent(4, True)}}) const( // hex: {{ '0x%06X'|format(method.request.id) }} @@ -150,7 +147,7 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) EncodeRequest({% f {% elif singleResponseValue %} {% set param = method.response.params|last %} -func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeRequest(clientMessage *protocol.ClientMessage) {{ lang_types_decode(param.type) }} { +func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(clientMessage *protocol.ClientMessage) {{ lang_types_decode(param.type) }} { frameIterator := clientMessage.FrameIterator() {% if response_fix_sized_params|length != 0 %} initialFrame := frameIterator.Next() @@ -168,7 +165,7 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeRequest(clie } {% else %} -func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeRequest(clientMessage *protocol.ClientMessage) ({% for param in method.response.params %}{{ escape_keyword(param.name)}} {{ lang_types_encode(param.type) }}{{ ", " if not loop.last }}{% endfor %} {% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists: boolean;{% endfor %}) { +func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(clientMessage *protocol.ClientMessage) ({% for param in method.response.params %}{{ escape_keyword(param.name)}} {{ lang_types_encode(param.type) }}{{ ", " if not loop.last }}{% endfor %} {% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists: boolean;{% endfor %}) { {% if response_fix_sized_params|length != 0 %} initialFrame := clientMessage.FrameIterator().Next() {% else %} diff --git a/util.py b/util.py index 0c3c673bc..0a12d2c91 100644 --- a/util.py +++ b/util.py @@ -386,7 +386,7 @@ class SupportedLanguages(Enum): SupportedLanguages.CS: 'src/Hazelcast.Net/Protocol/Codecs/', SupportedLanguages.PY: 'hazelcast/protocol/codec/', SupportedLanguages.TS: 'src/codec/', - SupportedLanguages.GO: 'internal/proto/' + SupportedLanguages.GO: 'hazelcast/internal/protocol/codec' } custom_codec_output_directories = { @@ -395,7 +395,7 @@ class SupportedLanguages(Enum): SupportedLanguages.CS: 'src/Hazelcast.Net/Protocol/CustomCodecs/', SupportedLanguages.PY: 'hazelcast/protocol/codec/custom/', SupportedLanguages.TS: 'src/codec/custom', - SupportedLanguages.GO: 'internal/custom/' + SupportedLanguages.GO: 'hazelcast/internal/protocol/codec/custom' } From 51d447b29bffd44d4cfbb14113f420359848db5d Mon Sep 17 00:00:00 2001 From: Umit UNAL Date: Mon, 21 Dec 2020 22:36:15 +0300 Subject: [PATCH 06/41] first codec generated. --- go/__init__.py | 70 +++++++++++++++++----------------- go/codec-template.go.j2 | 30 +++++++-------- go/custom-codec-template.go.j2 | 2 +- util.py | 4 +- 4 files changed, 52 insertions(+), 54 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index 90cc03120..63bf2bfbd 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -40,76 +40,74 @@ def __init__(self, name, path, is_builtin_codec=False, is_custom_codec=False): self.is_custom_codec = is_custom_codec def get_import_statement(self): - if self.is_custom_codec: - return "codecCustom \"github.com/hazelcast/hazelcast-go-client/hazelcast%s\"" % self.path - if self.is_builtin_codec: - return "codecBuiltin \"github.com/hazelcast/hazelcast-go-client/hazelcast%s\"" % self.path + if self.is_builtin_codec == True or self.is_custom_codec == True: + return "\"github.com/hazelcast/hazelcast-go-client/hazelcast%s\"" % self.path return "\"github.com/hazelcast/hazelcast-go-client/hazelcast%s\"" % self.path class PathHolders: UUID = ImportPathHolder('UUID', '/core') - Data = ImportPathHolder('Data', '/internal/protocol/serialization', is_builtin_codec=False, is_custom_codec=False) - DataCodec = ImportPathHolder("DataCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) - ByteArrayCodec = ImportPathHolder("ByteArrayCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) - LongArrayCodec = ImportPathHolder("LongArrayCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) + Data = ImportPathHolder('Data', '/protocol/serialization', is_builtin_codec=False, is_custom_codec=False) + DataCodec = ImportPathHolder("DataCodec", "/protocol/codec/internal", is_builtin_codec=True) + ByteArrayCodec = ImportPathHolder("ByteArrayCodec", "/protocol/codec/internal", is_builtin_codec=True) + LongArrayCodec = ImportPathHolder("LongArrayCodec", "/protocol/codec/internal", is_builtin_codec=True) Address = ImportPathHolder("Address", "/core") - AddressCodec = ImportPathHolder("AddressCodec", "/internal/protocol/codec/custom", is_custom_codec=True) + AddressCodec = ImportPathHolder("AddressCodec", "/protocol/codec/internal", is_custom_codec=True) ErrorHolder = ImportPathHolder("ErrorHolder", "/internal/protocol") - ErrorHolderCodec = ImportPathHolder("ErrorHolderCodec", "/internal/protocol/codec/custom", is_custom_codec=True) + ErrorHolderCodec = ImportPathHolder("ErrorHolderCodec", "/protocol/codec/internal", is_custom_codec=True) StackTraceElement = ImportPathHolder("StackTraceElement", "/internal/protocol") StackTraceElementCodec = ImportPathHolder("StackTraceElementCodec", - "/internal/protocol/codec/custom", is_custom_codec=True) + "/protocol/codec/internal", is_custom_codec=True) SimpleEntryView = ImportPathHolder("SimpleEntryView", "/core") - SimpleEntryViewCodec = ImportPathHolder("SimpleEntryViewCodec", "/internal/protocol/codec/custom", + SimpleEntryViewCodec = ImportPathHolder("SimpleEntryViewCodec", "/protocol/codec/internal", is_custom_codec=True) DistributedObjectInfo = ImportPathHolder("DistributedObjectInfo", "/core") - DistributedObjectInfoCodec = ImportPathHolder("DistributedObjectInfoCodec", "/internal/protocol/codec/custom", + DistributedObjectInfoCodec = ImportPathHolder("DistributedObjectInfoCodec", "/protocol/codec/internal", is_custom_codec=True) MemberInfo = ImportPathHolder("MemberInfo", "/core") - MemberInfoCodec = ImportPathHolder("MemberInfoCodec", "/internal/protocol/codec/custom", is_custom_codec=True) + MemberInfoCodec = ImportPathHolder("MemberInfoCodec", "/protocol/codec/internal", is_custom_codec=True) MemberVersion = ImportPathHolder("MemberVersion", "/core") - MemberVersionCodec = ImportPathHolder("MemberVersionCodec", "/internal/protocol/codec/custom", is_custom_codec=True) - StringCodec = ImportPathHolder("StringCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) - ListLongCodec = ImportPathHolder("ListLongCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) - ListIntegerCodec = ImportPathHolder("ListIntegerCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) - ListUUIDCodec = ImportPathHolder("ListUUIDCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) - ListDataCodec = ImportPathHolder("ListDataCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) - ListMultiFrameCodec = ImportPathHolder("ListMultiFrameCodec", "/internal/protocol/codec/builtin", + MemberVersionCodec = ImportPathHolder("MemberVersionCodec", "/protocol/codec/internal", is_custom_codec=True) + StringCodec = ImportPathHolder("StringCodec", "/protocol/codec/internal", is_builtin_codec=True) + ListLongCodec = ImportPathHolder("ListLongCodec", "/protocol/codec/internal", is_builtin_codec=True) + ListIntegerCodec = ImportPathHolder("ListIntegerCodec", "/protocol/codec/internal", is_builtin_codec=True) + ListUUIDCodec = ImportPathHolder("ListUUIDCodec", "/protocol/codec/internal", is_builtin_codec=True) + ListDataCodec = ImportPathHolder("ListDataCodec", "/protocol/codec/internal", is_builtin_codec=True) + ListMultiFrameCodec = ImportPathHolder("ListMultiFrameCodec", "/protocol/codec/internal", is_builtin_codec=True) - EntryListCodec = ImportPathHolder("EntryListCodec", "/internal/protocol/codec/builtin", is_builtin_codec=True) - EntryListLongByteArrayCodec = ImportPathHolder("EntryListLongByteArrayCodec", "/internal/protocol/codec/builtin", + EntryListCodec = ImportPathHolder("EntryListCodec", "/protocol/codec/internal", is_builtin_codec=True) + EntryListLongByteArrayCodec = ImportPathHolder("EntryListLongByteArrayCodec", "/protocol/codec/internal", is_builtin_codec=True) - EntryListIntegerUUIDCodec = ImportPathHolder("EntryListIntegerUUIDCodec", "/internal/protocol/codec/builtin", + EntryListIntegerUUIDCodec = ImportPathHolder("EntryListIntegerUUIDCodec", "/protocol/codec/internal", is_builtin_codec=True) - EntryListIntegerLongCodec = ImportPathHolder("EntryListIntegerLongCodec", "/internal/protocol/codec/builtin", + EntryListIntegerLongCodec = ImportPathHolder("EntryListIntegerLongCodec", "/protocol/codec/internal", is_builtin_codec=True) - EntryListIntegerIntegerCodec = ImportPathHolder("EntryListIntegerIntegerCodec", "/internal/protocol/codec/builtin", + EntryListIntegerIntegerCodec = ImportPathHolder("EntryListIntegerIntegerCodec", "/protocol/codec/internal", is_builtin_codec=True) - EntryListUUIDLongCodec = ImportPathHolder("EntryListUUIDLongCodec", "/internal/protocol/codec/builtin", + EntryListUUIDLongCodec = ImportPathHolder("EntryListUUIDLongCodec", "/protocol/codec/internal", is_builtin_codec=True) - EntryListUUIDUUIDCodec = ImportPathHolder("EntryListUUIDUUIDCodec", "/internal/protocol/codec/builtin", + EntryListUUIDUUIDCodec = ImportPathHolder("EntryListUUIDUUIDCodec", "/protocol/codec/internal", is_builtin_codec=True) EntryListUUIDListIntegerCodec = ImportPathHolder("EntryListUUIDListIntegerCodec", - "/internal/protocol/codec/builtin", + "/protocol/codec/internal", is_builtin_codec=True) - MapCodec = ImportPathHolder("MapCodec", "/internal/protocol/codec/builtin", + MapCodec = ImportPathHolder("MapCodec", "/protocol/codec/internal", is_builtin_codec=True) - CodecUtilCodec = ImportPathHolder("CodecUtil", "/internal/protocol/codec/builtin", + CodecUtilCodec = ImportPathHolder("CodecUtil", "/protocol/codec/internal", is_builtin_codec=True) IndexConfig = ImportPathHolder("IndexConfig", "/core") - IndexConfigCodec = ImportPathHolder("IndexConfigCodec", "/internal/protocol/codec/custom", is_custom_codec=True) + IndexConfigCodec = ImportPathHolder("IndexConfigCodec", "/protocol/codec/internal", is_custom_codec=True) BitmapIndexOptions = ImportPathHolder("BitmapIndexOptions", "/core") - BitmapIndexOptionsCodec = ImportPathHolder("BitmapIndexOptionsCodec", "/internal/protocol/codec/custom", + BitmapIndexOptionsCodec = ImportPathHolder("BitmapIndexOptionsCodec", "/protocol/codec/internal", is_custom_codec=True) PagingPredicateHolder = ImportPathHolder("PagingPredicateHolder", "/core") - PagingPredicateHolderCodec = ImportPathHolder("PagingPredicateHolderCodec", "/internal/protocol/codec/custom", + PagingPredicateHolderCodec = ImportPathHolder("PagingPredicateHolderCodec", "/protocol/codec/internal", is_custom_codec=True) AnchorDataListHolder = ImportPathHolder("AnchorDataListHolder", "/core") - AnchorDataListHolderCodec = ImportPathHolder("AnchorDataListHolderCodec", "/internal/protocol/codec/custom", + AnchorDataListHolderCodec = ImportPathHolder("AnchorDataListHolderCodec", "/protocol/codec/internal", is_custom_codec=True) RaftGroupId = ImportPathHolder("RaftGroupId", "/core", is_builtin_codec=False, is_custom_codec=False) - RaftGroupIdCodec = ImportPathHolder("RaftGroupIdCodec", "/internal/protocol/codec/custom", + RaftGroupIdCodec = ImportPathHolder("RaftGroupIdCodec", "/protocol/codec/internal", is_custom_codec=True) diff --git a/go/codec-template.go.j2 b/go/codec-template.go.j2 index 989ba9518..b05423cda 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.go.j2 @@ -1,31 +1,30 @@ {% macro encode_var_sized(param, loop_last) -%} {% if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - codecBuiltin.ListMultiFrameCodec.EncodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type)%}_contains_nullable{% endif %}{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}{% if loop_last %}, True{% endif %}) + internal.ListMultiFrameCodec.EncodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type)%}_contains_nullable{% endif %}{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}{% if loop_last %}, True{% endif %}) {%- elif is_var_sized_entry_list(param.type) -%} - codecBuiltin.EntryListCodec.Encode{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}, {{ key_type(lang_name, param.type) }}Codec.Encode, {{ value_type(lang_name, param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) + internal.EntryListCodec.Encode{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}, {{ key_type(lang_name, param.type) }}Codec.Encode, {{ value_type(lang_name, param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) {%- elif is_var_sized_map(param.type) -%} - codecBuiltin.MapCodec.Encode{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}, {{ key_type(lang_name, param.type) }}Codec.Encode, {{ value_type(lang_name, param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) + internal.MapCodec.Encode{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}, {{ key_type(lang_name, param.type) }}Codec.Encode, {{ value_type(lang_name, param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) {%- else -%} {%- if param.nullable -%} - codecBuiltin.CodecUtil.EncodeNullable(clientMessage, {{ param_name(param.name) }}, {{ lang_name(param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) + internal.CodecUtil.EncodeNullable(clientMessage, {{ param_name(param.name) }}, {{ lang_name(param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) {%- else -%} - codecBuiltin.{{ lang_name(param.type) }}Codec.Encode(clientMessage, {{ param_name(param.name) }}{% if loop_last %}, True{% endif %}) - {{ lang_types_decode(param.type) }} + internal.{{ lang_name(param.type) }}Codec.Encode(clientMessage, {{ param_name(param.name) }}{% if loop_last %}, True{% endif %}) {%- endif %} {% endif %} {%- endmacro %} {% macro decode_var_sized(param) -%} {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - codecBuiltin.ListMultiFrameCodec.DecodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type) %}_contains_nullable{% endif %}{% if param.nullable %}_nullable{% endif %}(frameIterator) + internal.ListMultiFrameCodec.DecodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type) %}_contains_nullable{% endif %}{% if param.nullable %}_nullable{% endif %}(frameIterator) {%- elif is_var_sized_entry_list(param.type) -%} - codecBuiltin.EntryListCodec.Decode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ key_type(lang_name, param.type) }}Codec.Decode, {{ value_type(lang_name, param.type) }}Codec.decode) + internal.EntryListCodec.Decode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ key_type(lang_name, param.type) }}Codec.Decode, {{ value_type(lang_name, param.type) }}Codec.decode) {%- elif is_var_sized_map(param.type) -%} - codecBuiltin.MapCodec.Decode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ key_type(lang_name, param.type) }}Codec.Decode, {{ value_type(lang_name, param.type) }}Codec.decode) + internal.MapCodec.Decode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ key_type(lang_name, param.type) }}Codec.Decode, {{ value_type(lang_name, param.type) }}Codec.decode) {%- else -%} {%- if param.nullable -%} - codecBuiltin.CodecUtil.DecodeNullable(clientMessage, {{ lang_name(param.type) }}Codec.Decode) + internal.CodecUtil.DecodeNullable(frameIterator, internal.{{ lang_name(param.type) }}Codec.Decode) {%- else -%} - codecBuiltin.{{ lang_name(param.type) }}Codec.Decode(clientMessage) + internal.{{ lang_name(param.type) }}Codec.Decode(clientMessage) {%- endif -%} {%- endif -%} {%- endmacro %} @@ -76,6 +75,7 @@ package codec import ( + "github.com/hazelcast/hazelcast-go-client/hazelcast/protocol" {{get_import_statements(request_fix_sized_params, request_var_sized_params, response_fix_sized_params, response_var_sized_params, event_fix_sized_params, event_var_sized_params)|indent(4, True)}}) const( @@ -129,7 +129,7 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) EncodeRequest({% f initialFrame := protocol.NewFrame(make([]byte, {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize)) {% for param in request_fix_sized_params %} - codecBuiltin.FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset, {{ escape_keyword(param.name) }}) + internal.FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset, {{ escape_keyword(param.name) }}) {% endfor %} clientMessage.AddFrame(initialFrame) clientMessage.SetMessageType({{ service_name|capital }}{{ method.name|capital }}CodecRequestMessageType) @@ -157,7 +157,7 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(cli {% endif %} {% for param in response_fix_sized_params %} - return codecBuiltin.FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Response{{param.name|capital}}Offset) + return internal.FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Response{{param.name|capital}}Offset) {% endfor %} {% for param in response_var_sized_params %} return {{ decode_var_sized(param) }} @@ -176,13 +176,13 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(cli {% for param in response_fix_sized_params %} {% if param in response_new_params %} if (initialFrame.content.length >= RESPONSE_{{ to_upper_snake_case(param.name) }}_OFFSET + BitsUtil.{{ param.type.upper() }}_SIZE_IN_BYTES) { - response.{{ escape_keyword(param.name) }} = FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, RESPONSE_{{to_upper_snake_case(param.name)}}_OFFSET); + response.{{ escape_keyword(param.name) }} = internal.FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, RESPONSE_{{to_upper_snake_case(param.name)}}_OFFSET); response.is{{ param.name|capital }}Exists = true; } else { response.is{{ param.name|capital }}Exists = false; } {% else %} - {{ escape_keyword(param.name) }} := FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, RESPONSE_{{to_upper_snake_case(param.name)}}_OFFSET) + {{ escape_keyword(param.name) }} := internal.FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, RESPONSE_{{to_upper_snake_case(param.name)}}_OFFSET) {% endif %} {% endfor %} {% for param in response_var_sized_params %} diff --git a/go/custom-codec-template.go.j2 b/go/custom-codec-template.go.j2 index b2476d84d..3dadc37de 100644 --- a/go/custom-codec-template.go.j2 +++ b/go/custom-codec-template.go.j2 @@ -44,7 +44,7 @@ * limitations under the License. */ -package custom +package internal import ( "github.com/hazelcast/hazelcast-go-client/hazelcast/core" diff --git a/util.py b/util.py index 0a12d2c91..0843dac7c 100644 --- a/util.py +++ b/util.py @@ -386,7 +386,7 @@ class SupportedLanguages(Enum): SupportedLanguages.CS: 'src/Hazelcast.Net/Protocol/Codecs/', SupportedLanguages.PY: 'hazelcast/protocol/codec/', SupportedLanguages.TS: 'src/codec/', - SupportedLanguages.GO: 'hazelcast/internal/protocol/codec' + SupportedLanguages.GO: 'hazelcast/protocol/codec/' } custom_codec_output_directories = { @@ -395,7 +395,7 @@ class SupportedLanguages(Enum): SupportedLanguages.CS: 'src/Hazelcast.Net/Protocol/CustomCodecs/', SupportedLanguages.PY: 'hazelcast/protocol/codec/custom/', SupportedLanguages.TS: 'src/codec/custom', - SupportedLanguages.GO: 'hazelcast/internal/protocol/codec/custom' + SupportedLanguages.GO: 'hazelcast/protocol/codec/internal' } From 5f1a4905fe1b8b69f0b0cdf58e8976c14333949d Mon Sep 17 00:00:00 2001 From: Umit UNAL Date: Tue, 22 Dec 2020 00:11:00 +0300 Subject: [PATCH 07/41] first codec generated. --- go/__init__.py | 1 + go/codec-template.go.j2 | 70 ++++++++++++++++++++++++++++++++++------- 2 files changed, 59 insertions(+), 12 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index 63bf2bfbd..6f179a33e 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -278,6 +278,7 @@ class PathHolders: "SqlError": "NA", "SqlColumnMetadata": "NA", "CPMember": "NA", + "MigrationState": "NA", "List_Long": "[]int64", "List_Integer": "[]int32", diff --git a/go/codec-template.go.j2 b/go/codec-template.go.j2 index b05423cda..2358bee62 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.go.j2 @@ -1,13 +1,13 @@ {% macro encode_var_sized(param, loop_last) -%} {% if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - internal.ListMultiFrameCodec.EncodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type)%}_contains_nullable{% endif %}{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}{% if loop_last %}, True{% endif %}) + internal.ListMultiFrameCodec.Encode{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ escape_keyword(param.name) }}, internal.{{ item_type(lang_name, param.type) }}Codec.Encode) {%- elif is_var_sized_entry_list(param.type) -%} - internal.EntryListCodec.Encode{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}, {{ key_type(lang_name, param.type) }}Codec.Encode, {{ value_type(lang_name, param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) + internal.EntryListCodec.Encode{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}, internal.{{ key_type(lang_name, param.type) }}Codec.Encode, internal.{{ value_type(lang_name, param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) {%- elif is_var_sized_map(param.type) -%} - internal.MapCodec.Encode{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}, {{ key_type(lang_name, param.type) }}Codec.Encode, {{ value_type(lang_name, param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) + internal.MapCodec.Encode{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}, internal.{{ key_type(lang_name, param.type) }}Codec.Encode, internal.{{ value_type(lang_name, param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) {%- else -%} {%- if param.nullable -%} - internal.CodecUtil.EncodeNullable(clientMessage, {{ param_name(param.name) }}, {{ lang_name(param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) + internal.CodecUtil.EncodeNullable(clientMessage, {{ param_name(param.name) }}, internal.{{ lang_name(param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) {%- else -%} internal.{{ lang_name(param.type) }}Codec.Encode(clientMessage, {{ param_name(param.name) }}{% if loop_last %}, True{% endif %}) {%- endif %} @@ -15,16 +15,16 @@ {%- endmacro %} {% macro decode_var_sized(param) -%} {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - internal.ListMultiFrameCodec.DecodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type) %}_contains_nullable{% endif %}{% if param.nullable %}_nullable{% endif %}(frameIterator) + internal.ListMultiFrameCodec.Decode{% if is_var_sized_list_contains_nullable(param.type) %}_contains_nullable{% endif %}{% if param.nullable %}_nullable{% endif %}(msg, {{ item_type(lang_name, param.type) }}Codec.decode) {%- elif is_var_sized_entry_list(param.type) -%} - internal.EntryListCodec.Decode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ key_type(lang_name, param.type) }}Codec.Decode, {{ value_type(lang_name, param.type) }}Codec.decode) + internal.EntryListCodec.Decode{% if param.nullable %}Nullable{% endif %}(frameIterator, internal.{{ key_type(lang_name, param.type) }}Codec.Decode, internal.{{ value_type(lang_name, param.type) }}Codec.Decode) {%- elif is_var_sized_map(param.type) -%} - internal.MapCodec.Decode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ key_type(lang_name, param.type) }}Codec.Decode, {{ value_type(lang_name, param.type) }}Codec.decode) + internal.MapCodec.Decode{% if param.nullable %}Nullable{% endif %}(v, internal.{{ key_type(lang_name, param.type) }}Codec.Decode, internal.{{ value_type(lang_name, param.type) }}Codec.Decode) {%- else -%} {%- if param.nullable -%} internal.CodecUtil.DecodeNullable(frameIterator, internal.{{ lang_name(param.type) }}Codec.Decode) {%- else -%} - internal.{{ lang_name(param.type) }}Codec.Decode(clientMessage) + internal.{{ lang_name(param.type) }}Codec.Decode(frameIterator) {%- endif -%} {%- endif -%} {%- endmacro %} @@ -91,7 +91,7 @@ const( {% endfor %} {#FIXED SIZED PARAMETER OFFSET CONSTANTS#} {% for param in request_fix_sized_params %} - {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset = {% if loop.first %}protocol.PartitionIDOffset + protocol.IntSizeInBytes{% else %}protocol.Request{{ loop.previtem.name|capital }}Offset + protocol.{{ loop.previtem.type|capitalize }}SizeInBytes{% endif %} + {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset = {% if loop.first %}protocol.PartitionIDOffset + protocol.IntSizeInBytes{% else %}{{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ loop.previtem.name|capital }}Offset + protocol.{{ loop.previtem.type|capitalize }}SizeInBytes{% endif %} {% if loop.last %} {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize = {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset + protocol.{{ param.type|capitalize }}SizeInBytes @@ -169,8 +169,8 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(cli {% if response_fix_sized_params|length != 0 %} initialFrame := clientMessage.FrameIterator().Next() {% else %} - // empty initial frame - clientMessage.FrameIterator().Next() + frameIterator := clientMessage.FrameIterator() + frameIterator.Next() {% endif %} {% for param in response_fix_sized_params %} @@ -182,7 +182,7 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(cli response.is{{ param.name|capital }}Exists = false; } {% else %} - {{ escape_keyword(param.name) }} := internal.FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, RESPONSE_{{to_upper_snake_case(param.name)}}_OFFSET) + {{ escape_keyword(param.name) }} = internal.FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Response{{ param.name|capital }}Offset) {% endif %} {% endfor %} {% for param in response_var_sized_params %} @@ -202,3 +202,49 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(cli } {% endif %} + +{# EVENTS#} +{% if method.events|length != 0 %} + + + func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(clientMessage *protocol.ClientMessage){ + message_type := clientMessage.GetMessageType() + } + message_type = msg.get_message_type() + {% for event in method.events %} + if message_type == _EVENT_{{ to_upper_snake_case(event.name) }}_MESSAGE_TYPE and handle_{{ param_name(event.name) }}_event is not None: + {% set new_event_params = new_params(event.since, event.params) %} + {% if fixed_params(event.params)|length != 0 %} + initial_frame = msg.next_frame() + {% else %} + msg.next_frame() + {% endif %} + {% for param in fixed_params(event.params) %} + {% do lang_types_decode(param.type) %} + {% if param in new_event_params %} + is_{{ param_name(param.name) }}_exists = False + {{ param_name(param.name) }} = {% if param.type == 'boolean' %}False{% elif param.type == 'UUID' %}None{% else %}0{% endif %} + + if len(initial_frame.buf) >= _EVENT_{{ to_upper_snake_case(event.name)}}_{{ to_upper_snake_case(param.name) }}_OFFSET + {{ param.type.upper() }}_SIZE_IN_BYTES: + {{ param_name(param.name) }} = FixSizedTypesCodec.decode_{{ param.type|lower }}(initial_frame.buf, _EVENT_{{ to_upper_snake_case(event.name)}}_{{ to_upper_snake_case(param.name) }}_OFFSET) + is_{{ param_name(param.name) }}_exists = True + {% else %} + {{ param_name(param.name) }} = FixSizedTypesCodec.decode_{{ param.type|lower }}(initial_frame.buf, _EVENT_{{ to_upper_snake_case(event.name)}}_{{ to_upper_snake_case(param.name) }}_OFFSET) + {% endif %} + {% endfor %} + {% for param in var_size_params(event.params) %} + {% do lang_types_decode(param.type) %} + {% if param in new_event_params %} + is_{{ param_name(param.name) }}_exists = False + {{ param_name(param.name) }} = None + if msg.has_next_frame(): + {{ param_name(param.name) }} = {{ decode_var_sized(param) }} + is_{{ param_name(param.name) }}_exists = True + {% else %} + {{ param_name(param.name) }} = {{ decode_var_sized(param) }} + {% endif %} + {% endfor %} + handle_{{ param_name(event.name) }}_event({% for param in event.params %}{% if param in new_event_params %}is_{{ param_name(param.name) }}_exists, {% endif %}{{ param_name(param.name) }}{% if not loop.last %}, {% endif %}{% endfor %}) + return + {% endfor %} +{% endif %} From f815201bd8cd7e07931c5cd6c1edfd3c7a4a7787 Mon Sep 17 00:00:00 2001 From: Umit UNAL Date: Tue, 22 Dec 2020 15:11:04 +0300 Subject: [PATCH 08/41] first codec generated. --- go/__init__.py | 86 ++++++++++++++++++++++------------------- go/codec-template.go.j2 | 82 ++++++++++++++++++++------------------- 2 files changed, 89 insertions(+), 79 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index 6f179a33e..8539dfac5 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -106,6 +106,11 @@ class PathHolders: AnchorDataListHolder = ImportPathHolder("AnchorDataListHolder", "/core") AnchorDataListHolderCodec = ImportPathHolder("AnchorDataListHolderCodec", "/protocol/codec/internal", is_custom_codec=True) + + EndpointQualifier = ImportPathHolder("EndpointQualifier", "/core", is_builtin_codec=False, is_custom_codec=False) + EndpointQualifierCodec = ImportPathHolder("EndpointQualifierCodec", "/protocol/codec/internal", + is_custom_codec=True) + RaftGroupId = ImportPathHolder("RaftGroupId", "/core", is_builtin_codec=False, is_custom_codec=False) RaftGroupIdCodec = ImportPathHolder("RaftGroupIdCodec", "/protocol/codec/internal", is_custom_codec=True) @@ -130,9 +135,9 @@ class PathHolders: "List_Integer": [PathHolders.ListIntegerCodec], "List_UUID": [PathHolders.ListUUIDCodec], "List_String": [PathHolders.ListMultiFrameCodec, PathHolders.StringCodec], - "List_Data": [PathHolders.ListMultiFrameCodec, PathHolders.DataCodec], + "List_Data": [PathHolders.Data, PathHolders.ListMultiFrameCodec, PathHolders.DataCodec], "ListCN_Data": [PathHolders.ListMultiFrameCodec, PathHolders.DataCodec], - "List_MemberInfo": [PathHolders.ListMultiFrameCodec, PathHolders.MemberInfoCodec], + 'List_MemberInfo': [PathHolders.MemberInfo, PathHolders.ListMultiFrameCodec, PathHolders.MemberInfoCodec], "List_DistributedObjectInfo": [PathHolders.ListMultiFrameCodec, PathHolders.DistributedObjectInfoCodec], "List_StackTraceElement": [PathHolders.ListMultiFrameCodec, PathHolders.StackTraceElementCodec], "EntryList_String_String": [PathHolders.EntryListCodec, PathHolders.StringCodec], @@ -154,6 +159,7 @@ class PathHolders: "BitmapIndexOptions": [PathHolders.BitmapIndexOptions, PathHolders.BitmapIndexOptionsCodec], "AnchorDataListHolder": [PathHolders.AnchorDataListHolder, PathHolders.AnchorDataListHolderCodec], "PagingPredicateHolder": [PathHolders.PagingPredicateHolder, PathHolders.PagingPredicateHolderCodec], + "Map_EndpointQualifier_Address": [PathHolders.MapCodec, PathHolders.EndpointQualifierCodec, PathHolders.AddressCodec] } _go_types_common = { @@ -169,11 +175,13 @@ class PathHolders: "byteArray": "[]byte", "String": "string", "Data": "serialization.Data", + "Pair": "serialization.Pair", "Address": "core.Address", "ErrorHolder": "core.ErrorHolder", "StackTraceElement": "core.StackTraceElement", - "SimpleEntryView": "Pair", + "MemberInfo": "core.MemberInfo", + "SimpleEntryView": "protocol.Pair", "RaftGroupId": "core.RaftGroupId", "WanReplicationRef": "NA", "HotRestartConfig": "NA", @@ -200,10 +208,10 @@ class PathHolders: "ListenerConfigHolder": "NA", "CacheSimpleEntryListenerConfig": "NA", "ClientBwListEntry": "NA", - "EndpointQualifier": "NA", + "EndpointQualifier": "core.EndpointQualifier", "Map_String_String": "map[string]string", - "Map_EndpointQualifier_Address": "NA", + "Map_EndpointQualifier_Address": "map[core.EndpointQualifier]core.Address", "List_CPMember": "NA" } @@ -214,11 +222,11 @@ class PathHolders: "ScheduledTaskHandler": "NA", "Xid": "NA", "ClientBwListEntry": "NA", - "MemberInfo": "NA", - "MemberVersion": "NA", + "MemberInfo": "core.MemberInfo", + "MemberVersion": "core.MemberVersion", "MCEvent": "NA", - "AnchorDataListHolder": "AnchorDataListHolder", - "PagingPredicateHolder": "PagingPredicateHolder", + "AnchorDataListHolder": "core.AnchorDataListHolder", + "PagingPredicateHolder": "core.PagingPredicateHolder", "SqlQueryId": "NA", "SqlError": "NA", "SqlColumnMetadata": "NA", @@ -234,7 +242,7 @@ class PathHolders: "List_List_Data": "[]serialization.Data", "ListCN_Data": "[]serialization.Data", "List_ListCN_Data": "NA", - "List_MemberInfo": "[]MemberInfo", + "List_MemberInfo": "[]core.MemberInfo", "List_ScheduledTaskHandler": "NA", "List_CacheEventData": "NA", "List_QueryCacheConfigHolder": "NA", @@ -249,18 +257,18 @@ class PathHolders: "List_MCEvent": "NA", "List_SqlColumnMetadata": "NA", - "EntryList_String_String": "[]Pair", - "EntryList_String_byteArray": "[]Pair", - "EntryList_Long_byteArray": "[]Pair", - "EntryList_Integer_UUID": "[]Pair", - "EntryList_Integer_Long": "[]Pair", - "EntryList_Integer_Integer": "[]Pair", - "EntryList_UUID_Long": "[]Pair", - "EntryList_String_EntryList_Integer_Long": "[]Pair", - "EntryList_UUID_UUID": "[]Pair", - "EntryList_UUID_List_Integer": "[]Pair", - "EntryList_Data_Data": "[]Pair", - "EntryList_Data_List_Data": "[]Pair", + "EntryList_String_String": "[]protocol.Pair", + "EntryList_String_byteArray": "[]protocol.Pair", + "EntryList_Long_byteArray": "[]protocol.Pair", + "EntryList_Integer_UUID": "[]protocol.Pair", + "EntryList_Integer_Long": "[]protocol.Pair", + "EntryList_Integer_Integer": "[]protocol.Pair", + "EntryList_UUID_Long": "[]protocol.Pair", + "EntryList_String_EntryList_Integer_Long": "[]protocol.Pair", + "EntryList_UUID_UUID": "[]protocol.Pair", + "EntryList_UUID_List_Integer": "[]protocol.Pair", + "EntryList_Data_Data": "[]protocol.Pair", + "EntryList_Data_List_Data": "[]protocol.Pair", } _go_types_decode = { @@ -269,11 +277,11 @@ class PathHolders: "ScheduledTaskHandler": "NA", "Xid": "NA", "ClientBwListEntry": "NA", - "MemberInfo": "MemberInfo", - "MemberVersion": "MemberVersion", + "MemberInfo": "core.MemberInfo", + "MemberVersion": "core.MemberVersion", "MCEvent": "NA", - "AnchorDataListHolder": "AnchorDataListHolder", - "PagingPredicateHolder": "PagingPredicateHolder", + "AnchorDataListHolder": "core.AnchorDataListHolder", + "PagingPredicateHolder": "core.PagingPredicateHolder", "SqlQueryId": "NA", "SqlError": "NA", "SqlColumnMetadata": "NA", @@ -289,7 +297,7 @@ class PathHolders: "List_List_Data": "[]serialization.Data", "ListCN_Data": "[]serialization.Data", "List_ListCN_Data": "NA", - "List_MemberInfo": "[]MemberInfo", + "List_MemberInfo": "[]core.MemberInfo", "List_CacheEventData": "NA", "List_QueryCacheConfigHolder": "NA", "List_DistributedObjectInfo": "[]core.DistributedObjectInfo", @@ -305,16 +313,16 @@ class PathHolders: "List_SqlColumnMetadata": "NA", "List_CPMember": "NA", - "EntryList_String_String": "[]Pair", - "EntryList_String_byteArray": "[]Pair", - "EntryList_Long_byteArray": "[]Pair", - "EntryList_Integer_UUID": "[]Pair", - "EntryList_Integer_Long": "[]Pair", - "EntryList_Integer_Integer": "[]Pair", - "EntryList_UUID_Long": "[]Pair", - "EntryList_String_EntryList_Integer_Long": "[]Pair", - "EntryList_UUID_UUID": "[]Pair", - "EntryList_UUID_List_Integer": "[]Pair", - "EntryList_Data_Data": "[]Pair", - "EntryList_Data_List_Data": "[]Pair", + "EntryList_String_String": "[]protocol.Pair", + "EntryList_String_byteArray": "[]protocol.Pair", + "EntryList_Long_byteArray": "[]protocol.Pair", + "EntryList_Integer_UUID": "[]protocol.Pair", + "EntryList_Integer_Long": "[]protocol.Pair", + "EntryList_Integer_Integer": "[]protocol.Pair", + "EntryList_UUID_Long": "[]protocol.Pair", + "EntryList_String_EntryList_Integer_Long": "[]protocol.Pair", + "EntryList_UUID_UUID": "[]protocol.Pair", + "EntryList_UUID_List_Integer": "[]protocol.Pair", + "EntryList_Data_Data": "[]protocol.Pair", + "EntryList_Data_List_Data": "[]protocol.Pair", } diff --git a/go/codec-template.go.j2 b/go/codec-template.go.j2 index 2358bee62..1ac81cb54 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.go.j2 @@ -15,7 +15,7 @@ {%- endmacro %} {% macro decode_var_sized(param) -%} {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - internal.ListMultiFrameCodec.Decode{% if is_var_sized_list_contains_nullable(param.type) %}_contains_nullable{% endif %}{% if param.nullable %}_nullable{% endif %}(msg, {{ item_type(lang_name, param.type) }}Codec.decode) + internal.ListMultiFrameCodec.Decode{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}{% if param.nullable %}_nullable{% endif %}(frameIterator, internal.{{ item_type(lang_name, param.type) }}Codec.Decode) {%- elif is_var_sized_entry_list(param.type) -%} internal.EntryListCodec.Decode{% if param.nullable %}Nullable{% endif %}(frameIterator, internal.{{ key_type(lang_name, param.type) }}Codec.Decode, internal.{{ value_type(lang_name, param.type) }}Codec.Decode) {%- elif is_var_sized_map(param.type) -%} @@ -167,7 +167,8 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(cli func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(clientMessage *protocol.ClientMessage) ({% for param in method.response.params %}{{ escape_keyword(param.name)}} {{ lang_types_encode(param.type) }}{{ ", " if not loop.last }}{% endfor %} {% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists: boolean;{% endfor %}) { {% if response_fix_sized_params|length != 0 %} - initialFrame := clientMessage.FrameIterator().Next() + frameIterator := clientMessage.FrameIterator() + initialFrame := frameIterator.Next() {% else %} frameIterator := clientMessage.FrameIterator() frameIterator.Next() @@ -194,7 +195,7 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(cli response.is{{ param.name|capital }}Exists = false; } {% else %} - {{ escape_keyword(param.name) }} := {{ decode_var_sized(param) }} + {{ escape_keyword(param.name) }} = {{ decode_var_sized(param) }} {% endif %} {% endfor %} @@ -206,45 +207,46 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(cli {# EVENTS#} {% if method.events|length != 0 %} - - func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(clientMessage *protocol.ClientMessage){ - message_type := clientMessage.GetMessageType() - } - message_type = msg.get_message_type() - {% for event in method.events %} - if message_type == _EVENT_{{ to_upper_snake_case(event.name) }}_MESSAGE_TYPE and handle_{{ param_name(event.name) }}_event is not None: - {% set new_event_params = new_params(event.since, event.params) %} - {% if fixed_params(event.params)|length != 0 %} - initial_frame = msg.next_frame() +func ({{ service_name|lower }}{{ method.name|capital }}Codec) Handle(clientMessage *protocol.ClientMessage, {% for event in method.events%}handle{{ event.name|capital }}Event func({% for param in event.params %}{% if param in new_event_params %}is{{ param.name|capital }}Exists, {% endif %}{{param.name}} {{ lang_types_encode(param.type) }}{% if not loop.last %}, {% endif %}{% endfor %}){% if not loop.last %}, {% endif %}{% endfor %}){ + messageType := clientMessage.GetMessageType() + frameIterator := clientMessage.FrameIterator() + {% for event in method.events%} + if messageType == {{ service_name|capital }}{{ method.name|capital }}CodecEvent{{ event.name|capital }}MessageType { + {% set new_event_params = new_params(event.since, event.params) %} + {% if fixed_params(event.params)|length != 0 %} + initialFrame := frameIterator.Next() + {% else %} + //empty initial frame + frameIterator.Next() + {% endif %} + {% for param in fixed_params(event.params) %} + {% if param in new_event_params %} + let is{{ param.name|capital }}Exists = false + let {{ escape_keyword(param.name) }} = {% if param.type == 'boolean' %}false{% elif param.type == 'UUID' %}null{% else %}0{% endif %} + if (initialFrame.content.length >= EVENT_{{ to_upper_snake_case(event.name)}}_{{ to_upper_snake_case(param.name) }}_OFFSET + BitsUtil.{{ param.type.upper() }}_SIZE_IN_BYTES) { + {{ escape_keyword(param.name) }} = FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.content, EVENT_{{ to_upper_snake_case(event.name)}}_{{ to_upper_snake_case(param.name) }}_OFFSET) + is{{ param.name|capital }}Exists = true; + } {% else %} - msg.next_frame() + {{ escape_keyword(param.name) }} := internal.FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Event{{ event.name|capital }}{{param.name|capital}}Offset) {% endif %} - {% for param in fixed_params(event.params) %} - {% do lang_types_decode(param.type) %} - {% if param in new_event_params %} - is_{{ param_name(param.name) }}_exists = False - {{ param_name(param.name) }} = {% if param.type == 'boolean' %}False{% elif param.type == 'UUID' %}None{% else %}0{% endif %} - - if len(initial_frame.buf) >= _EVENT_{{ to_upper_snake_case(event.name)}}_{{ to_upper_snake_case(param.name) }}_OFFSET + {{ param.type.upper() }}_SIZE_IN_BYTES: - {{ param_name(param.name) }} = FixSizedTypesCodec.decode_{{ param.type|lower }}(initial_frame.buf, _EVENT_{{ to_upper_snake_case(event.name)}}_{{ to_upper_snake_case(param.name) }}_OFFSET) - is_{{ param_name(param.name) }}_exists = True - {% else %} - {{ param_name(param.name) }} = FixSizedTypesCodec.decode_{{ param.type|lower }}(initial_frame.buf, _EVENT_{{ to_upper_snake_case(event.name)}}_{{ to_upper_snake_case(param.name) }}_OFFSET) - {% endif %} - {% endfor %} - {% for param in var_size_params(event.params) %} - {% do lang_types_decode(param.type) %} - {% if param in new_event_params %} - is_{{ param_name(param.name) }}_exists = False - {{ param_name(param.name) }} = None - if msg.has_next_frame(): - {{ param_name(param.name) }} = {{ decode_var_sized(param) }} - is_{{ param_name(param.name) }}_exists = True - {% else %} - {{ param_name(param.name) }} = {{ decode_var_sized(param) }} - {% endif %} - {% endfor %} - handle_{{ param_name(event.name) }}_event({% for param in event.params %}{% if param in new_event_params %}is_{{ param_name(param.name) }}_exists, {% endif %}{{ param_name(param.name) }}{% if not loop.last %}, {% endif %}{% endfor %}) + {% endfor %} + {% for param in var_size_params(event.params) %} + {% if param in new_event_params %} + let is{{ param.name|capital }}Exists = false + let {{ escape_keyword(param.name) }} = null + if (iterator.hasNextFrame()) { + {{ escape_keyword(param.name) }} = {{ decode_var_sized(param) }} + is{{ param.name|capital }}Exists = true; + } + {% else %} + {{ escape_keyword(param.name) }} := {{ decode_var_sized(param) }} + {% endif %} + {% endfor %} + handle{{ event.name|capital }}Event({% for param in event.params %}{% if param in new_event_params %}is{{ param.name|capital }}Exists, {% endif %}{{param.name}}{% if not loop.last %}, {% endif %}{% endfor %}) return + } {% endfor %} +} + {% endif %} From f3f729a0e1e67c8f224540624f4ae2c450156d56 Mon Sep 17 00:00:00 2001 From: Umit UNAL Date: Wed, 23 Dec 2020 16:59:24 +0300 Subject: [PATCH 09/41] first codec generated. --- go/__init__.py | 37 ++++++++++-------- go/codec-template.go.j2 | 5 +-- go/custom-codec-template.go.j2 | 70 ++++++++++++++++++++-------------- util.py | 4 +- 4 files changed, 66 insertions(+), 50 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index 8539dfac5..943e99dac 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -7,6 +7,11 @@ "Transaction", "ContinuousQuery", "DurableExecutor", "CardinalityEstimator", "ScheduledExecutor", "DynamicConfig", "CPSubsystem"} +def go_escape_keyword(value): + if value not in go_reserved_keywords: + return value + return "_" + value + def go_types_encode(key): try: @@ -40,7 +45,7 @@ def __init__(self, name, path, is_builtin_codec=False, is_custom_codec=False): self.is_custom_codec = is_custom_codec def get_import_statement(self): - if self.is_builtin_codec == True or self.is_custom_codec == True: + if self.is_builtin_codec or self.is_custom_codec: return "\"github.com/hazelcast/hazelcast-go-client/hazelcast%s\"" % self.path return "\"github.com/hazelcast/hazelcast-go-client/hazelcast%s\"" % self.path @@ -97,21 +102,21 @@ class PathHolders: is_builtin_codec=True) IndexConfig = ImportPathHolder("IndexConfig", "/core") IndexConfigCodec = ImportPathHolder("IndexConfigCodec", "/protocol/codec/internal", is_custom_codec=True) - BitmapIndexOptions = ImportPathHolder("BitmapIndexOptions", "/core") + BitmapIndexOptions = ImportPathHolder("BitmapIndexOptions", "/config") BitmapIndexOptionsCodec = ImportPathHolder("BitmapIndexOptionsCodec", "/protocol/codec/internal", is_custom_codec=True) PagingPredicateHolder = ImportPathHolder("PagingPredicateHolder", "/core") PagingPredicateHolderCodec = ImportPathHolder("PagingPredicateHolderCodec", "/protocol/codec/internal", is_custom_codec=True) - AnchorDataListHolder = ImportPathHolder("AnchorDataListHolder", "/core") + AnchorDataListHolder = ImportPathHolder("AnchorDataListHolder", "/protocol") AnchorDataListHolderCodec = ImportPathHolder("AnchorDataListHolderCodec", "/protocol/codec/internal", is_custom_codec=True) - EndpointQualifier = ImportPathHolder("EndpointQualifier", "/core", is_builtin_codec=False, is_custom_codec=False) + EndpointQualifier = ImportPathHolder("EndpointQualifier", "/protocol") EndpointQualifierCodec = ImportPathHolder("EndpointQualifierCodec", "/protocol/codec/internal", is_custom_codec=True) - RaftGroupId = ImportPathHolder("RaftGroupId", "/core", is_builtin_codec=False, is_custom_codec=False) + RaftGroupId = ImportPathHolder("RaftGroupId", "/protocol", is_builtin_codec=False, is_custom_codec=False) RaftGroupIdCodec = ImportPathHolder("RaftGroupIdCodec", "/protocol/codec/internal", is_custom_codec=True) @@ -181,8 +186,8 @@ class PathHolders: "ErrorHolder": "core.ErrorHolder", "StackTraceElement": "core.StackTraceElement", "MemberInfo": "core.MemberInfo", - "SimpleEntryView": "protocol.Pair", - "RaftGroupId": "core.RaftGroupId", + "SimpleEntryView": "core.SimpleEntryView", + "RaftGroupId": "protocol.RaftGroupId", "WanReplicationRef": "NA", "HotRestartConfig": "NA", "EventJournalConfig": "NA", @@ -203,15 +208,15 @@ class PathHolders: "MapStoreConfigHolder": "NA", "DistributedObjectInfo": "core.DistributedObjectInfo", "IndexConfig": "core.IndexConfig", - "BitmapIndexOptions": "core.BitmapIndexOptions", + "BitmapIndexOptions": "config.BitmapIndexOptions", "AttributeConfig": "NA", "ListenerConfigHolder": "NA", "CacheSimpleEntryListenerConfig": "NA", "ClientBwListEntry": "NA", - "EndpointQualifier": "core.EndpointQualifier", + "EndpointQualifier": "protocol.EndpointQualifier", "Map_String_String": "map[string]string", - "Map_EndpointQualifier_Address": "map[core.EndpointQualifier]core.Address", + "Map_EndpointQualifier_Address": "map[protocol.EndpointQualifier]core.Address", "List_CPMember": "NA" } @@ -225,8 +230,8 @@ class PathHolders: "MemberInfo": "core.MemberInfo", "MemberVersion": "core.MemberVersion", "MCEvent": "NA", - "AnchorDataListHolder": "core.AnchorDataListHolder", - "PagingPredicateHolder": "core.PagingPredicateHolder", + "AnchorDataListHolder": "protocol.AnchorDataListHolder", + "PagingPredicateHolder": "protocol.PagingPredicateHolder", "SqlQueryId": "NA", "SqlError": "NA", "SqlColumnMetadata": "NA", @@ -252,7 +257,7 @@ class PathHolders: "List_AttributeConfig": "NA", "List_ListenerConfigHolder": "NA", "List_CacheSimpleEntryListenerConfig": "NA", - "List_StackTraceElement": "[]StackTraceElement", + "List_StackTraceElement": "[]protocol.StackTraceElement", "List_ClientBwListEntry": "NA", "List_MCEvent": "NA", "List_SqlColumnMetadata": "NA", @@ -280,8 +285,8 @@ class PathHolders: "MemberInfo": "core.MemberInfo", "MemberVersion": "core.MemberVersion", "MCEvent": "NA", - "AnchorDataListHolder": "core.AnchorDataListHolder", - "PagingPredicateHolder": "core.PagingPredicateHolder", + "AnchorDataListHolder": "protocol.AnchorDataListHolder", + "PagingPredicateHolder": "protocol.PagingPredicateHolder", "SqlQueryId": "NA", "SqlError": "NA", "SqlColumnMetadata": "NA", @@ -306,7 +311,7 @@ class PathHolders: "List_AttributeConfig": "NA", "List_ListenerConfigHolder": "NA", "List_CacheSimpleEntryListenerConfig": "NA", - "List_StackTraceElement": "[]StackTraceElement", + "List_StackTraceElement": "[]protocol.StackTraceElement", "List_ClientBwListEntry": "NA", "List_MCEvent": "NA", "List_ScheduledTaskHandler": "NA", diff --git a/go/codec-template.go.j2 b/go/codec-template.go.j2 index 1ac81cb54..cd89bb3bf 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.go.j2 @@ -75,8 +75,7 @@ package codec import ( - "github.com/hazelcast/hazelcast-go-client/hazelcast/protocol" -{{get_import_statements(request_fix_sized_params, request_var_sized_params, response_fix_sized_params, response_var_sized_params, event_fix_sized_params, event_var_sized_params)|indent(4, True)}}) +) const( // hex: {{ '0x%06X'|format(method.request.id) }} @@ -141,12 +140,10 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) EncodeRequest({% f return clientMessage } - {#RESPONSE DECODE#} {% if noResponseValue %} {% elif singleResponseValue %} {% set param = method.response.params|last %} - func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(clientMessage *protocol.ClientMessage) {{ lang_types_decode(param.type) }} { frameIterator := clientMessage.FrameIterator() {% if response_fix_sized_params|length != 0 %} diff --git a/go/custom-codec-template.go.j2 b/go/custom-codec-template.go.j2 index 3dadc37de..177d05fea 100644 --- a/go/custom-codec-template.go.j2 +++ b/go/custom-codec-template.go.j2 @@ -1,33 +1,54 @@ {% macro encode_var_sized(param) -%} {% if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - codecBuiltin.ListMultiFrameCodec.Encode{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}(), {{ item_type(lang_name, param.type) }}Codec::encode) + ListMultiFrameCodec.Encode{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}(), {{ item_type(lang_name, param.type) }}Codec.Encode) {%- elif is_var_sized_entry_list(param.type) -%} - codecBuiltin.EntryListCodec.Encode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}(), {{ key_type(lang_name, param.type) }}Codec::encode, {{ value_type(lang_name, param.type) }}Codec::encodeNullable) + EntryListCodec.Encode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}(), {{ key_type(lang_name, param.type) }}Codec.Encode, {{ value_type(lang_name, param.type) }}Codec.EncodeNullable) {%- elif is_var_sized_map(param.type) -%} - codecBuiltin.MapCodec.Encode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}(), {{ key_type(lang_name, param.type) }}Codec::encode, {{ value_type(lang_name, param.type) }}Codec::encode) + MapCodec.Encode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}(), {{ key_type(lang_name, param.type) }}Codec.Encode, {{ value_type(lang_name, param.type) }}Codec.Encode) {%- else -%} {%- if param.nullable -%} - codecBuiltin.CodecUtil.EncodeNullable(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}(), {{ lang_name(param.type) }}Codec::encode) + CodecUtil.EncodeNullable(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}(), {{ lang_name(param.type) }}Codec.Encode) {%- else -%} - codecBuiltin.{{ lang_name(param.type) }}Codec.Encode(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}get{% endif %}{{ param.name|capital }}()) + {{ lang_name(param.type) }}Codec.Encode(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}Is{% else %}Get{% endif %}{{ param.name|capital }}()) {%- endif %} {% endif %} {%- endmacro %} {% macro decode_var_sized(param) -%} {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - codecBuiltin.ListMultiFrameCodec.Decode{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(iterator, {{ item_type(lang_name, param.type) }}Codec::decode) + ListMultiFrameCodec.Decode{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(frameIterator, {{ item_type(lang_name, param.type) }}Codec.Decode) {%- elif is_var_sized_entry_list(param.type) -%} - codecBuiltin.EntryListCodec.Decode{% if param.nullable %}Nullable{% endif %}(frameIterator, {{ key_type(lang_name, param.type) }}Codec::decode, {{ value_type(lang_name, param.type) }}Codec::DecodeNullable) + EntryListCodec.Decode{% if param.nullable %}Nullable{% endif %}(frameIterator, {{ key_type(lang_name, param.type) }}Codec.Decode, {{ value_type(lang_name, param.type) }}Codec.DecodeNullable) {%- elif is_var_sized_map(param.type) -%} - codecBuiltin.MapCodec.Decode{% if param.nullable %}Nullable{% endif %}(frameIterator, {{ key_type(lang_name, param.type) }}Codec::decode, {{ value_type(lang_name, param.type) }}Codec::decode) + MapCodec.Decode{% if param.nullable %}Nullable{% endif %}(frameIterator, {{ key_type(lang_name, param.type) }}Codec.Decode, {{ value_type(lang_name, param.type) }}Codec.Decode) {%- else -%} {%- if param.nullable -%} - codecBuiltin.CodecUtil.DecodeNullable(frameIterator, {{ lang_name(param.type) }}Codec::decode) + CodecUtil.DecodeNullable(frameIterator, {{ lang_name(param.type) }}Codec.Decode) {%- else -%} - codecBuiltin.{{ lang_name(param.type) }}Codec.Decode(frameIterator) + {{ lang_name(param.type) }}Codec.Decode(frameIterator) {%- endif -%} {%- endif -%} {%- endmacro %} +{% macro get_import_statements() -%} + {% set imported_paths = [] %} + {%- for params in varargs -%} + {% for param in params %} + {% set path_holders = get_import_path_holders(param.type) %} + {% if path_holders is not none %} + {%- for path_holder in path_holders -%} + {% if not path_holder.path in imported_paths %} + {%- do imported_paths.append(path_holder.path) -%} + {{ path_holder.get_import_statement() }} + {% endif %} + {% endfor %} + {% endif %} + {%- endfor -%} + {%- endfor -%} +{%- endmacro %} +{% set fix_sized_params = fixed_params(codec.params) %} +{% set var_sized_params = var_size_params(codec.params) %} +{% set new_codec_params = new_params(codec.since, codec.params) %} +{% set fix_sized_new_params = new_params(codec.since, fix_sized_params) %} +{% set should_add_begin_frame = (fix_sized_params|length > fix_sized_new_params|length) or fix_sized_params|length == 0 %} /* * Copyright (c) 2008-2020, Hazelcast, Inc. All Rights Reserved. * @@ -47,26 +68,18 @@ package internal import ( - "github.com/hazelcast/hazelcast-go-client/hazelcast/core" - "github.com/hazelcast/hazelcast-go-client/hazelcast/internal/protocol" - codecBuiltin "github.com/hazelcast/hazelcast-go-client/hazelcast/internal/protocol/codec/builtin" ) - -{% set fix_sized_params = fixed_params(codec.params) %} -{% set var_sized_params = var_size_params(codec.params) %} -{% set new_codec_params = new_params(codec.since, codec.params) %} -{% set fix_sized_new_params = new_params(codec.since, fix_sized_params) %} -{% set should_add_begin_frame = (fix_sized_params|length > fix_sized_new_params|length) or fix_sized_params|length == 0 %} - +{% if fix_sized_params|length > 0 %} const( {% for param in fix_sized_params %} {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset = {% if loop.first %}0{% else %}{{ to_upper_snake_case(loop.previtem.name)}}_FIELD_OFFSET + {{ loop.previtem.type.upper() }}_SIZE_IN_BYTES{% endif %} {% if loop.last %} - {{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize = {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset + protocol.{{ param.type }}SizeInBytes + {{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize = {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset + protocol.{{ param.type|capital }}SizeInBytes {% endif %} {% endfor %} ) +{% endif %} type {{ codec.name|lower }}Codec struct {} @@ -81,7 +94,7 @@ func ({{ codec.name|lower }}Codec) Encode(clientMessage *protocol.ClientMessage, {% if loop.first %} initialFrame := protocol.NewFrame(make([]byte,{{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize)) {% endif %} - codecBuiltin.FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset, {{ param_name(codec.name)}}.{{ escape_keyword(param.name) }}) + FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset, {{ param_name(codec.name)}}.Get{{ escape_keyword(param.name)|capital }}()) {% if loop.last %} {% if not should_add_begin_frame %} initialFrame.flags |= BEGIN_DATA_STRUCTURE_FLAG @@ -102,8 +115,8 @@ func ({{ codec.name|lower }}Codec) Encode(clientMessage *protocol.ClientMessage, clientMessage.AddFrame(protocol.EndFrame.Copy()) } -func ({{ codec.name|lower }}Codec) Decode(frameIterator *protocol.ForwardFrameIterator) { -// begin frame +func ({{ codec.name|lower }}Codec) Decode(frameIterator *protocol.ForwardFrameIterator) {{ lang_types_encode(codec.name) }} { + // begin frame {% if should_add_begin_frame %} frameIterator.Next() {% endif %} @@ -115,11 +128,11 @@ func ({{ codec.name|lower }}Codec) Decode(frameIterator *protocol.ForwardFrameIt is{{ param.name|capital }}Exists := false let {{ escape_keyword(param.name) }} = {% if param.type == 'boolean' %}false{% elif param.type == 'UUID' %}null{% else %}0{% endif %} if (initialFrame.content.length >= {{ to_upper_snake_case(param.name) }}_OFFSET + BitsUtil.{{ param.type.upper() }}_SIZE_IN_BYTES) { - {{ escape_keyword(param.name) }} = codecBuiltin.FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ to_upper_snake_case(param.name) }}_OFFSET) + {{ escape_keyword(param.name) }} = FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ to_upper_snake_case(param.name) }}_OFFSET) is{{ param.name|capital }}Exists = true } {% else %} - {{ escape_keyword(param.name) }} := codecBuiltin.FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset) + {{ escape_keyword(param.name) }} := FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset) {% endif %} {% endfor %} {% for param in var_sized_params %} @@ -141,7 +154,7 @@ func ({{ codec.name|lower }}Codec) Decode(frameIterator *protocol.ForwardFrameIt {% endif %} {% endfor %} - codecBuiltin.CodecUtil.FastForwardToEndFrame(frameIterator) + CodecUtil.FastForwardToEndFrame(frameIterator) {% set ctor_params = [] %} {% for param in codec.params %} @@ -149,5 +162,6 @@ func ({{ codec.name|lower }}Codec) Decode(frameIterator *protocol.ForwardFrameIt {% do ctor_params.append(param) %} {% endif %} {% endfor %} - return core.New{{ codec.name }}({% for param in ctor_params %}{% if param in new_codec_params %}is{{ param.name|capital }}Exists, {% endif %}{{ escape_keyword(param.name) }}{% if not loop.last %}, {% endif %}{% endfor %}) + + return {{ lang_types_encode(codec.name).split('.')[0] }}.New{{ lang_types_encode(codec.name).split('.')[1] }}({% for param in ctor_params %}{% if param in new_codec_params %}is{{ param.name|capital }}Exists, {% endif %}{{ escape_keyword(param.name) }}{% if not loop.last %}, {% endif %}{% endfor %}) } diff --git a/util.py b/util.py index 0843dac7c..c4ac97770 100644 --- a/util.py +++ b/util.py @@ -11,7 +11,7 @@ from binary import FixedLengthTypes, FixedListTypes, FixedEntryListTypes, FixedMapTypes from java import java_types_encode, java_types_decode -from go import go_types_encode, go_types_decode, go_ignore_service_list, go_get_import_path_holders +from go import go_types_encode, go_types_decode, go_ignore_service_list, go_get_import_path_holders, go_escape_keyword from cs import cs_types_encode, cs_types_decode, cs_escape_keyword, cs_ignore_service_list from cpp import cpp_types_encode, cpp_types_decode, cpp_ignore_service_list, get_size, is_trivial from ts import ts_types_encode, ts_types_decode, ts_escape_keyword, ts_ignore_service_list, ts_get_import_path_holders @@ -459,7 +459,7 @@ def inner(*names): SupportedLanguages.CPP: lambda x: x, SupportedLanguages.TS: ts_escape_keyword, SupportedLanguages.PY: py_escape_keyword, - SupportedLanguages.GO: lambda x: x, + SupportedLanguages.GO: go_escape_keyword, }, 'get_import_path_holders': { SupportedLanguages.JAVA: lambda x: x, From f35fa90eb01b84e8a3b0d7e7e148a2b9571c2737 Mon Sep 17 00:00:00 2001 From: Umit UNAL Date: Sun, 27 Dec 2020 20:27:35 +0300 Subject: [PATCH 10/41] first codec generated. --- go/__init__.py | 6 ++--- go/codec-template.go.j2 | 26 +++++++++------------ go/custom-codec-template.go.j2 | 41 ++++++++++++++++++---------------- 3 files changed, 36 insertions(+), 37 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index 943e99dac..ea672aaba 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -183,8 +183,8 @@ class PathHolders: "Pair": "serialization.Pair", "Address": "core.Address", - "ErrorHolder": "core.ErrorHolder", - "StackTraceElement": "core.StackTraceElement", + "ErrorHolder": "protocol.ErrorHolder", + "StackTraceElement": "protocol.StackTraceElement", "MemberInfo": "core.MemberInfo", "SimpleEntryView": "core.SimpleEntryView", "RaftGroupId": "protocol.RaftGroupId", @@ -207,7 +207,7 @@ class PathHolders: "QueryCacheConfigHolder": "NA", "MapStoreConfigHolder": "NA", "DistributedObjectInfo": "core.DistributedObjectInfo", - "IndexConfig": "core.IndexConfig", + "IndexConfig": "config.IndexConfig", "BitmapIndexOptions": "config.BitmapIndexOptions", "AttributeConfig": "NA", "ListenerConfigHolder": "NA", diff --git a/go/codec-template.go.j2 b/go/codec-template.go.j2 index cd89bb3bf..7459ef14d 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.go.j2 @@ -1,8 +1,8 @@ {% macro encode_var_sized(param, loop_last) -%} {% if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - internal.ListMultiFrameCodec.Encode{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ escape_keyword(param.name) }}, internal.{{ item_type(lang_name, param.type) }}Codec.Encode) + internal.ListMultiFrameCodec.EncodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ escape_keyword(param.name) }}) {%- elif is_var_sized_entry_list(param.type) -%} - internal.EntryListCodec.Encode{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}, internal.{{ key_type(lang_name, param.type) }}Codec.Encode, internal.{{ value_type(lang_name, param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) + internal.EntryListCodec.EncodeFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}) {%- elif is_var_sized_map(param.type) -%} internal.MapCodec.Encode{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}, internal.{{ key_type(lang_name, param.type) }}Codec.Encode, internal.{{ value_type(lang_name, param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) {%- else -%} @@ -15,14 +15,14 @@ {%- endmacro %} {% macro decode_var_sized(param) -%} {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - internal.ListMultiFrameCodec.Decode{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}{% if param.nullable %}_nullable{% endif %}(frameIterator, internal.{{ item_type(lang_name, param.type) }}Codec.Decode) + internal.ListMultiFrameCodec.DecodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}{% if param.nullable %}_nullable{% endif %}(frameIterator) {%- elif is_var_sized_entry_list(param.type) -%} - internal.EntryListCodec.Decode{% if param.nullable %}Nullable{% endif %}(frameIterator, internal.{{ key_type(lang_name, param.type) }}Codec.Decode, internal.{{ value_type(lang_name, param.type) }}Codec.Decode) + internal.EntryListCodec.DecodeFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}{% if param.nullable %}Nullable{% endif %}(frameIterator) {%- elif is_var_sized_map(param.type) -%} internal.MapCodec.Decode{% if param.nullable %}Nullable{% endif %}(v, internal.{{ key_type(lang_name, param.type) }}Codec.Decode, internal.{{ value_type(lang_name, param.type) }}Codec.Decode) {%- else -%} {%- if param.nullable -%} - internal.CodecUtil.DecodeNullable(frameIterator, internal.{{ lang_name(param.type) }}Codec.Decode) + internal.CodecUtil.DecodeNullableFor{{ lang_name(param.type) }}(frameIterator) {%- else -%} internal.{{ lang_name(param.type) }}Codec.Decode(frameIterator) {%- endif -%} @@ -71,21 +71,20 @@ // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. - package codec import ( -) +{{get_import_statements(request_fix_sized_params, request_var_sized_params, response_fix_sized_params, response_var_sized_params, event_fix_sized_params, event_var_sized_params)|indent(4, True)}}) const( // hex: {{ '0x%06X'|format(method.request.id) }} - {{ service_name|capital }}{{ method.name|capital }}CodecRequestMessageType int32 = {{ method.request.id }} + {{ service_name|capital }}{{ method.name|capital }}CodecRequestMessageType = int32({{ method.request.id }}) // hex: {{ '0x%06X'|format(method.response.id) }} - {{ service_name|capital }}{{ method.name|capital }}CodecResponseMessageType int32 = {{ method.response.id }} + {{ service_name|capital }}{{ method.name|capital }}CodecResponseMessageType = int32({{ method.response.id }}) {% for event in method.events%} // hex: {{ '0x%06X'|format(event.id) }} - {{ service_name|capital }}{{ method.name|capital }}CodecEvent{{ event.name|capital }}MessageType int32 = {{ event.id }} + {{ service_name|capital }}{{ method.name|capital }}CodecEvent{{ event.name|capital }}MessageType = int32({{ event.id }}) {% endfor %} {#FIXED SIZED PARAMETER OFFSET CONSTANTS#} @@ -140,6 +139,7 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) EncodeRequest({% f return clientMessage } + {#RESPONSE DECODE#} {% if noResponseValue %} {% elif singleResponseValue %} @@ -161,8 +161,7 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(cli {% endfor %} } {% else %} - -func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(clientMessage *protocol.ClientMessage) ({% for param in method.response.params %}{{ escape_keyword(param.name)}} {{ lang_types_encode(param.type) }}{{ ", " if not loop.last }}{% endfor %} {% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists: boolean;{% endfor %}) { +func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(clientMessage *protocol.ClientMessage) ({% for param in method.response.params %}{{ escape_keyword(param.name)}} {{ lang_types_encode(param.type) }}{{ ", " if not loop.last }}{% endfor %}{% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists: boolean;{% endfor %}) { {% if response_fix_sized_params|length != 0 %} frameIterator := clientMessage.FrameIterator() initialFrame := frameIterator.Next() @@ -197,10 +196,8 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(cli {% endfor %} return {% for param in method.response.params %}{{ escape_keyword(param.name)}}{{ ", " if not loop.last }}{% endfor %} {% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists: boolean;{% endfor %} - } {% endif %} - {# EVENTS#} {% if method.events|length != 0 %} @@ -245,5 +242,4 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) Handle(clientMessa } {% endfor %} } - {% endif %} diff --git a/go/custom-codec-template.go.j2 b/go/custom-codec-template.go.j2 index 177d05fea..bd57797f0 100644 --- a/go/custom-codec-template.go.j2 +++ b/go/custom-codec-template.go.j2 @@ -1,13 +1,13 @@ {% macro encode_var_sized(param) -%} {% if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - ListMultiFrameCodec.Encode{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}(), {{ item_type(lang_name, param.type) }}Codec.Encode) + ListMultiFrameCodec.EncodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}()) {%- elif is_var_sized_entry_list(param.type) -%} - EntryListCodec.Encode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}(), {{ key_type(lang_name, param.type) }}Codec.Encode, {{ value_type(lang_name, param.type) }}Codec.EncodeNullable) + EntryListCodec.EncodeFor{{ value_type(lang_name, param.type) }}And{{ key_type(lang_name, param.type) }}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}()) {%- elif is_var_sized_map(param.type) -%} - MapCodec.Encode{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}(), {{ key_type(lang_name, param.type) }}Codec.Encode, {{ value_type(lang_name, param.type) }}Codec.Encode) + MapCodec.EncodeFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}()) {%- else -%} {%- if param.nullable -%} - CodecUtil.EncodeNullable(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}(), {{ lang_name(param.type) }}Codec.Encode) + CodecUtil.EncodeNullableFor{{ lang_name(param.type) }}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}()) {%- else -%} {{ lang_name(param.type) }}Codec.Encode(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}Is{% else %}Get{% endif %}{{ param.name|capital }}()) {%- endif %} @@ -15,14 +15,14 @@ {%- endmacro %} {% macro decode_var_sized(param) -%} {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - ListMultiFrameCodec.Decode{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(frameIterator, {{ item_type(lang_name, param.type) }}Codec.Decode) + ListMultiFrameCodec.DecodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(frameIterator) {%- elif is_var_sized_entry_list(param.type) -%} EntryListCodec.Decode{% if param.nullable %}Nullable{% endif %}(frameIterator, {{ key_type(lang_name, param.type) }}Codec.Decode, {{ value_type(lang_name, param.type) }}Codec.DecodeNullable) {%- elif is_var_sized_map(param.type) -%} - MapCodec.Decode{% if param.nullable %}Nullable{% endif %}(frameIterator, {{ key_type(lang_name, param.type) }}Codec.Decode, {{ value_type(lang_name, param.type) }}Codec.Decode) + MapCodec.DecodeFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}{% if param.nullable %}Nullable{% endif %}(frameIterator) {%- else -%} {%- if param.nullable -%} - CodecUtil.DecodeNullable(frameIterator, {{ lang_name(param.type) }}Codec.Decode) + CodecUtil.DecodeNullableFor{{ lang_name(param.type) }}(frameIterator) {%- else -%} {{ lang_name(param.type) }}Codec.Decode(frameIterator) {%- endif -%} @@ -64,15 +64,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package internal import ( -) +{{ get_import_statements(fix_sized_params, var_sized_params)|indent(4, True) }}) + {% if fix_sized_params|length > 0 %} const( {% for param in fix_sized_params %} - {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset = {% if loop.first %}0{% else %}{{ to_upper_snake_case(loop.previtem.name)}}_FIELD_OFFSET + {{ loop.previtem.type.upper() }}_SIZE_IN_BYTES{% endif %} + {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset = {% if loop.first %}0{% else %}{{ codec.name|capital }}Codec{{ loop.previtem.name|capital }}FieldOffset + protocol.{{ loop.previtem.type|capital }}SizeInBytes{% endif %} {% if loop.last %} {{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize = {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset + protocol.{{ param.type|capital }}SizeInBytes @@ -86,15 +86,20 @@ type {{ codec.name|lower }}Codec struct {} var {{ codec.name|capital }}Codec {{ codec.name|lower }}Codec func ({{ codec.name|lower }}Codec) Encode(clientMessage *protocol.ClientMessage, {{ param_name(codec.name) }} {{ lang_types_encode(codec.name) }}){ - {% if should_add_begin_frame %} clientMessage.AddFrame(protocol.BeginFrame.Copy()) {% endif %} {% for param in fix_sized_params %} - {% if loop.first %} + {% if loop.last %} initialFrame := protocol.NewFrame(make([]byte,{{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize)) {% endif %} +{% endfor %} +{% for param in fix_sized_params %} + {% if escape_keyword(param.name).startswith('_') == true %} + FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset, {{ param_name(codec.name)}}.Get{{ escape_keyword(param.name)[1:]|capital }}()) + {% else %} FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset, {{ param_name(codec.name)}}.Get{{ escape_keyword(param.name)|capital }}()) + {% endif %} {% if loop.last %} {% if not should_add_begin_frame %} initialFrame.flags |= BEGIN_DATA_STRUCTURE_FLAG @@ -143,19 +148,17 @@ func ({{ codec.name|lower }}Codec) Decode(frameIterator *protocol.ForwardFrameIt {% continue %} {% endif %} {% if param in new_codec_params %} - is{{ param.name|capital }}Exists = false - {{ escape_keyword(param.name) }} = null - if (!clientMessage.peekNextFrame().isEndFrame()) { - {{ escape_keyword(param.name) }} := {{ decode_var_sized(param) }} - is{{ param.name|capital }}Exists := true + is{{ param.name|capital }}Exists := false + var {{ escape_keyword(param.name) }} interface{} + if (!frameIterator.PeekNext().IsEndFrame()) { + {{ escape_keyword(param.name) }} = {{ decode_var_sized(param) }} + is{{ param.name|capital }}Exists = true } {% else %} {{ escape_keyword(param.name) }} := {{ decode_var_sized(param) }} {% endif %} {% endfor %} - CodecUtil.FastForwardToEndFrame(frameIterator) - {% set ctor_params = [] %} {% for param in codec.params %} {% if lang_types_decode(param.type) != '!skip' %} From 53e1d437a0efa12fe887e84aa8584e8095e8ec37 Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Wed, 24 Feb 2021 05:56:44 +0300 Subject: [PATCH 11/41] Go codec refactoring first state - Functionalized encoder/decoders - Adapt new Go package hierarchy --- go/__init__.py | 443 ++++++++++++++++----------------- go/codec-template.go.j2 | 91 ++++--- go/custom-codec-template.go.j2 | 56 ++--- util.py | 6 +- 4 files changed, 287 insertions(+), 309 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index ea672aaba..dfe414fa8 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -1,3 +1,5 @@ +CLIENT_VERSION = 4 + go_reserved_keywords = {"break", "default", "func", "interface", "select", "case", "defer", "go", "map", "struct", "chan", "else", "goto", "package", "switch", "const", "fallthrough", "if", "range", "type", "continue", "for", "import", "return", "var"} @@ -7,6 +9,7 @@ "Transaction", "ContinuousQuery", "DurableExecutor", "CardinalityEstimator", "ScheduledExecutor", "DynamicConfig", "CPSubsystem"} + def go_escape_keyword(value): if value not in go_reserved_keywords: return value @@ -37,6 +40,18 @@ def go_get_import_path_holders(param_type): return import_paths.get(param_type, []) +def go_get_import_statements(*args): + import_statements = set() + for arg in args: + params = [arg] if isinstance(arg, str) else arg + for param in params: + type = param["type"] if isinstance(param, dict) else param + for path_holder in import_paths.get(type, []): + if path_holder.path: + import_statements.add(path_holder.import_statement) + return import_statements + + class ImportPathHolder: def __init__(self, name, path, is_builtin_codec=False, is_custom_codec=False): self.name = name @@ -44,290 +59,260 @@ def __init__(self, name, path, is_builtin_codec=False, is_custom_codec=False): self.is_builtin_codec = is_builtin_codec self.is_custom_codec = is_custom_codec - def get_import_statement(self): - if self.is_builtin_codec or self.is_custom_codec: - return "\"github.com/hazelcast/hazelcast-go-client/hazelcast%s\"" % self.path - return "\"github.com/hazelcast/hazelcast-go-client/hazelcast%s\"" % self.path + @property + def import_statement(self): + if not self.path: + return "" + return '''"github.com/hazelcast/hazelcast-go-client/v%s/internal%s"''' % (CLIENT_VERSION, self.path) class PathHolders: - UUID = ImportPathHolder('UUID', '/core') - Data = ImportPathHolder('Data', '/protocol/serialization', is_builtin_codec=False, is_custom_codec=False) - DataCodec = ImportPathHolder("DataCodec", "/protocol/codec/internal", is_builtin_codec=True) - ByteArrayCodec = ImportPathHolder("ByteArrayCodec", "/protocol/codec/internal", is_builtin_codec=True) - LongArrayCodec = ImportPathHolder("LongArrayCodec", "/protocol/codec/internal", is_builtin_codec=True) Address = ImportPathHolder("Address", "/core") - AddressCodec = ImportPathHolder("AddressCodec", "/protocol/codec/internal", is_custom_codec=True) - ErrorHolder = ImportPathHolder("ErrorHolder", "/internal/protocol") - ErrorHolderCodec = ImportPathHolder("ErrorHolderCodec", "/protocol/codec/internal", is_custom_codec=True) - StackTraceElement = ImportPathHolder("StackTraceElement", "/internal/protocol") - StackTraceElementCodec = ImportPathHolder("StackTraceElementCodec", - "/protocol/codec/internal", is_custom_codec=True) - SimpleEntryView = ImportPathHolder("SimpleEntryView", "/core") - SimpleEntryViewCodec = ImportPathHolder("SimpleEntryViewCodec", "/protocol/codec/internal", - is_custom_codec=True) + AddressCodec = ImportPathHolder("AddressCodec", "", is_custom_codec=True) + AnchorDataListHolder = ImportPathHolder("AnchorDataListHolder", "") + AnchorDataListHolderCodec = ImportPathHolder("AnchorDataListHolderCodec", "", is_custom_codec=True) + BitmapIndexOptions = ImportPathHolder("BitmapIndexOptions", "/config") + BitmapIndexOptionsCodec = ImportPathHolder("BitmapIndexOptionsCodec", "", is_custom_codec=True) + ByteArrayCodec = ImportPathHolder("ByteArrayCodec", "", is_builtin_codec=True) + CodecUtilCodec = ImportPathHolder("CodecUtil", "", is_builtin_codec=True) + Data = ImportPathHolder('Data', '/serialization') + DataCodec = ImportPathHolder("DataCodec", "", is_builtin_codec=True) DistributedObjectInfo = ImportPathHolder("DistributedObjectInfo", "/core") - DistributedObjectInfoCodec = ImportPathHolder("DistributedObjectInfoCodec", "/protocol/codec/internal", - is_custom_codec=True) + DistributedObjectInfoCodec = ImportPathHolder("DistributedObjectInfoCodec", "", is_custom_codec=True) + # EndpointQualifier = ImportPathHolder("EndpointQualifier", "/protocol") + EndpointQualifierCodec = ImportPathHolder("EndpointQualifierCodec", "", is_custom_codec=True) + EntryListCodec = ImportPathHolder("EntryListCodec", "", is_builtin_codec=True) + EntryListIntegerIntegerCodec = ImportPathHolder("EntryListIntegerIntegerCodec", "", is_builtin_codec=True) + EntryListIntegerLongCodec = ImportPathHolder("EntryListIntegerLongCodec", "", is_builtin_codec=True) + EntryListIntegerUUIDCodec = ImportPathHolder("EntryListIntegerUUIDCodec", "", is_builtin_codec=True) + EntryListLongByteArrayCodec = ImportPathHolder("EntryListLongByteArrayCodec", "", is_builtin_codec=True) + EntryListUUIDListIntegerCodec = ImportPathHolder("EntryListUUIDListIntegerCodec", "", is_builtin_codec=True) + EntryListUUIDLongCodec = ImportPathHolder("EntryListUUIDLongCodec", "", is_builtin_codec=True) + EntryListUUIDUUIDCodec = ImportPathHolder("EntryListUUIDUUIDCodec", "", is_builtin_codec=True) + ErrorHolder = ImportPathHolder("ErrorHolder", "") + ErrorHolderCodec = ImportPathHolder("ErrorHolderCodec", "", is_custom_codec=True) + IndexConfig = ImportPathHolder("IndexConfig", "/core") + IndexConfigCodec = ImportPathHolder("IndexConfigCodec", "", is_custom_codec=True) + ListDataCodec = ImportPathHolder("ListDataCodec", "", is_builtin_codec=True) + ListIntegerCodec = ImportPathHolder("ListIntegerCodec", "", is_builtin_codec=True) + ListLongCodec = ImportPathHolder("ListLongCodec", "", is_builtin_codec=True) + ListMultiFrameCodec = ImportPathHolder("ListMultiFrameCodec", "", is_builtin_codec=True) + ListUUIDCodec = ImportPathHolder("ListUUIDCodec", "", is_builtin_codec=True) + LongArrayCodec = ImportPathHolder("LongArrayCodec", "", is_builtin_codec=True) + MapCodec = ImportPathHolder("MapCodec", "", is_builtin_codec=True) MemberInfo = ImportPathHolder("MemberInfo", "/core") - MemberInfoCodec = ImportPathHolder("MemberInfoCodec", "/protocol/codec/internal", is_custom_codec=True) + MemberInfoCodec = ImportPathHolder("MemberInfoCodec", "", is_custom_codec=True) MemberVersion = ImportPathHolder("MemberVersion", "/core") - MemberVersionCodec = ImportPathHolder("MemberVersionCodec", "/protocol/codec/internal", is_custom_codec=True) - StringCodec = ImportPathHolder("StringCodec", "/protocol/codec/internal", is_builtin_codec=True) - ListLongCodec = ImportPathHolder("ListLongCodec", "/protocol/codec/internal", is_builtin_codec=True) - ListIntegerCodec = ImportPathHolder("ListIntegerCodec", "/protocol/codec/internal", is_builtin_codec=True) - ListUUIDCodec = ImportPathHolder("ListUUIDCodec", "/protocol/codec/internal", is_builtin_codec=True) - ListDataCodec = ImportPathHolder("ListDataCodec", "/protocol/codec/internal", is_builtin_codec=True) - ListMultiFrameCodec = ImportPathHolder("ListMultiFrameCodec", "/protocol/codec/internal", - is_builtin_codec=True) - EntryListCodec = ImportPathHolder("EntryListCodec", "/protocol/codec/internal", is_builtin_codec=True) - EntryListLongByteArrayCodec = ImportPathHolder("EntryListLongByteArrayCodec", "/protocol/codec/internal", - is_builtin_codec=True) - EntryListIntegerUUIDCodec = ImportPathHolder("EntryListIntegerUUIDCodec", "/protocol/codec/internal", - is_builtin_codec=True) - EntryListIntegerLongCodec = ImportPathHolder("EntryListIntegerLongCodec", "/protocol/codec/internal", - is_builtin_codec=True) - EntryListIntegerIntegerCodec = ImportPathHolder("EntryListIntegerIntegerCodec", "/protocol/codec/internal", - is_builtin_codec=True) - EntryListUUIDLongCodec = ImportPathHolder("EntryListUUIDLongCodec", "/protocol/codec/internal", - is_builtin_codec=True) - EntryListUUIDUUIDCodec = ImportPathHolder("EntryListUUIDUUIDCodec", "/protocol/codec/internal", - is_builtin_codec=True) - EntryListUUIDListIntegerCodec = ImportPathHolder("EntryListUUIDListIntegerCodec", - "/protocol/codec/internal", - is_builtin_codec=True) - MapCodec = ImportPathHolder("MapCodec", "/protocol/codec/internal", - is_builtin_codec=True) - CodecUtilCodec = ImportPathHolder("CodecUtil", "/protocol/codec/internal", - is_builtin_codec=True) - IndexConfig = ImportPathHolder("IndexConfig", "/core") - IndexConfigCodec = ImportPathHolder("IndexConfigCodec", "/protocol/codec/internal", is_custom_codec=True) - BitmapIndexOptions = ImportPathHolder("BitmapIndexOptions", "/config") - BitmapIndexOptionsCodec = ImportPathHolder("BitmapIndexOptionsCodec", "/protocol/codec/internal", - is_custom_codec=True) + MemberVersionCodec = ImportPathHolder("MemberVersionCodec", "", is_custom_codec=True) PagingPredicateHolder = ImportPathHolder("PagingPredicateHolder", "/core") - PagingPredicateHolderCodec = ImportPathHolder("PagingPredicateHolderCodec", "/protocol/codec/internal", - is_custom_codec=True) - AnchorDataListHolder = ImportPathHolder("AnchorDataListHolder", "/protocol") - AnchorDataListHolderCodec = ImportPathHolder("AnchorDataListHolderCodec", "/protocol/codec/internal", - is_custom_codec=True) - - EndpointQualifier = ImportPathHolder("EndpointQualifier", "/protocol") - EndpointQualifierCodec = ImportPathHolder("EndpointQualifierCodec", "/protocol/codec/internal", - is_custom_codec=True) - - RaftGroupId = ImportPathHolder("RaftGroupId", "/protocol", is_builtin_codec=False, is_custom_codec=False) - RaftGroupIdCodec = ImportPathHolder("RaftGroupIdCodec", "/protocol/codec/internal", - is_custom_codec=True) + PagingPredicateHolderCodec = ImportPathHolder("PagingPredicateHolderCodec", "", is_custom_codec=True) + RaftGroupId = ImportPathHolder("RaftGroupId", "") + RaftGroupIdCodec = ImportPathHolder("RaftGroupIdCodec", "", is_custom_codec=True) + SimpleEntryView = ImportPathHolder("SimpleEntryView", "/core") + SimpleEntryViewCodec = ImportPathHolder("SimpleEntryViewCodec", "", is_custom_codec=True) + StackTraceElement = ImportPathHolder("StackTraceElement", "") + StackTraceElementCodec = ImportPathHolder("StackTraceElementCodec", "", is_custom_codec=True) + StringCodec = ImportPathHolder("StringCodec", "", is_builtin_codec=True) + UUID = ImportPathHolder('UUID', '/core') import_paths = { - "UUID": [PathHolders.UUID], + "Address": [PathHolders.Address, PathHolders.AddressCodec], + "AnchorDataListHolder": [PathHolders.AnchorDataListHolder, PathHolders.AnchorDataListHolderCodec], + "BitmapIndexOptions": [PathHolders.BitmapIndexOptions, PathHolders.BitmapIndexOptionsCodec], "CodecUtil": PathHolders.CodecUtilCodec, - "longArray": [PathHolders.LongArrayCodec], - "byteArray": [PathHolders.ByteArrayCodec], - "String": [PathHolders.StringCodec], "Data": [PathHolders.Data, PathHolders.DataCodec], - "Address": [PathHolders.Address, PathHolders.AddressCodec], - "ErrorHolder": [PathHolders.ErrorHolder, PathHolders.ErrorHolderCodec], - "StackTraceElement": [PathHolders.StackTraceElement, PathHolders.StackTraceElementCodec], - "SimpleEntryView": [PathHolders.SimpleEntryView, PathHolders.SimpleEntryViewCodec], "DistributedObjectInfo": [PathHolders.DistributedObjectInfo, PathHolders.DistributedObjectInfoCodec], - "MemberInfo": [PathHolders.MemberInfo, PathHolders.MemberInfoCodec], - "MemberVersion": [PathHolders.MemberVersion, PathHolders.MemberVersionCodec], - "RaftGroupId": [PathHolders.RaftGroupId, PathHolders.RaftGroupIdCodec], - "List_Long": [PathHolders.ListLongCodec], - "List_Integer": [PathHolders.ListIntegerCodec], - "List_UUID": [PathHolders.ListUUIDCodec], - "List_String": [PathHolders.ListMultiFrameCodec, PathHolders.StringCodec], - "List_Data": [PathHolders.Data, PathHolders.ListMultiFrameCodec, PathHolders.DataCodec], - "ListCN_Data": [PathHolders.ListMultiFrameCodec, PathHolders.DataCodec], - 'List_MemberInfo': [PathHolders.MemberInfo, PathHolders.ListMultiFrameCodec, PathHolders.MemberInfoCodec], - "List_DistributedObjectInfo": [PathHolders.ListMultiFrameCodec, PathHolders.DistributedObjectInfoCodec], - "List_StackTraceElement": [PathHolders.ListMultiFrameCodec, PathHolders.StackTraceElementCodec], + "EntryList_Data_Data": [PathHolders.EntryListCodec, PathHolders.DataCodec], + "EntryList_Data_List_Data": [PathHolders.EntryListCodec, PathHolders.DataCodec, PathHolders.ListDataCodec], + "EntryList_Integer_Integer": [PathHolders.EntryListIntegerIntegerCodec], + "EntryList_Integer_Long": [PathHolders.EntryListIntegerLongCodec], + "EntryList_Integer_UUID": [PathHolders.EntryListIntegerUUIDCodec], + "EntryList_Long_byteArray": [PathHolders.EntryListLongByteArrayCodec], + "EntryList_String_EntryList_Integer_Long": [PathHolders.EntryListCodec, PathHolders.StringCodec, PathHolders.EntryListIntegerLongCodec], "EntryList_String_String": [PathHolders.EntryListCodec, PathHolders.StringCodec], "EntryList_String_byteArray": [PathHolders.EntryListCodec, PathHolders.StringCodec, PathHolders.ByteArrayCodec], - "EntryList_Long_byteArray": [PathHolders.EntryListLongByteArrayCodec], - "EntryList_Integer_UUID": [PathHolders.EntryListIntegerUUIDCodec], - "EntryList_Integer_Long": [PathHolders.EntryListIntegerLongCodec], - "EntryList_Integer_Integer": [PathHolders.EntryListIntegerIntegerCodec], + "EntryList_UUID_List_Integer": [PathHolders.EntryListUUIDListIntegerCodec], "EntryList_UUID_Long": [PathHolders.EntryListUUIDLongCodec], - "EntryList_String_EntryList_Integer_Long": [PathHolders.EntryListCodec, PathHolders.StringCodec, - PathHolders.EntryListIntegerLongCodec], "EntryList_UUID_UUID": [PathHolders.EntryListUUIDUUIDCodec], - "EntryList_UUID_List_Integer": [PathHolders.EntryListUUIDListIntegerCodec], - "EntryList_Data_Data": [PathHolders.EntryListCodec, PathHolders.DataCodec], - "EntryList_Data_List_Data": [PathHolders.EntryListCodec, PathHolders.DataCodec, PathHolders.ListDataCodec], - "Map_String_String": [PathHolders.MapCodec, PathHolders.StringCodec], + "ErrorHolder": [PathHolders.ErrorHolder, PathHolders.ErrorHolderCodec], "IndexConfig": [PathHolders.IndexConfig, PathHolders.IndexConfigCodec], + "ListCN_Data": [PathHolders.ListMultiFrameCodec, PathHolders.DataCodec], "ListIndexConfig": [PathHolders.IndexConfigCodec, PathHolders.ListMultiFrameCodec], - "BitmapIndexOptions": [PathHolders.BitmapIndexOptions, PathHolders.BitmapIndexOptionsCodec], - "AnchorDataListHolder": [PathHolders.AnchorDataListHolder, PathHolders.AnchorDataListHolderCodec], + "List_Data": [PathHolders.Data, PathHolders.ListMultiFrameCodec, PathHolders.DataCodec], + "List_DistributedObjectInfo": [PathHolders.ListMultiFrameCodec, PathHolders.DistributedObjectInfoCodec], + "List_Integer": [PathHolders.ListIntegerCodec], + "List_Long": [PathHolders.ListLongCodec], + "List_StackTraceElement": [PathHolders.ListMultiFrameCodec, PathHolders.StackTraceElementCodec], + "List_String": [PathHolders.ListMultiFrameCodec, PathHolders.StringCodec], + "List_UUID": [PathHolders.ListUUIDCodec], + "Map_EndpointQualifier_Address": [PathHolders.MapCodec, PathHolders.EndpointQualifierCodec, PathHolders.AddressCodec], + "Map_String_String": [PathHolders.MapCodec, PathHolders.StringCodec], + "MemberInfo": [PathHolders.MemberInfo, PathHolders.MemberInfoCodec], + "MemberVersion": [PathHolders.MemberVersion, PathHolders.MemberVersionCodec], "PagingPredicateHolder": [PathHolders.PagingPredicateHolder, PathHolders.PagingPredicateHolderCodec], - "Map_EndpointQualifier_Address": [PathHolders.MapCodec, PathHolders.EndpointQualifierCodec, PathHolders.AddressCodec] + "RaftGroupId": [PathHolders.RaftGroupId, PathHolders.RaftGroupIdCodec], + "SimpleEntryView": [PathHolders.SimpleEntryView, PathHolders.SimpleEntryViewCodec], + "StackTraceElement": [PathHolders.StackTraceElement, PathHolders.StackTraceElementCodec], + "String": [PathHolders.StringCodec], + "UUID": [PathHolders.UUID], + "byteArray": [PathHolders.ByteArrayCodec], + "longArray": [PathHolders.LongArrayCodec], + 'List_MemberInfo': [PathHolders.MemberInfo, PathHolders.ListMultiFrameCodec, PathHolders.MemberInfoCodec], } _go_types_common = { - "boolean": "bool", - "int": "int32", - "long": "int64", - "byte": "byte", - "Integer": "int32", - "Long": "int64", - "UUID": "core.UUID", - - "longArray": "[]int64", - "byteArray": "[]byte", - "String": "string", - "Data": "serialization.Data", - "Pair": "serialization.Pair", - "Address": "core.Address", + "AttributeConfig": "NA", + "BitmapIndexOptions": "config.BitmapIndexOptions", + "CacheConfigHolder": "NA", + "CacheEventData": "NA", + "CacheSimpleEntryListenerConfig": "NA", + "ClientBwListEntry": "NA", + "Data": "serialization.Data", + "DistributedObjectInfo": "core.DistributedObjectInfo", + "DurationConfig": "NA", + "EndpointQualifier": "protocol.EndpointQualifier", "ErrorHolder": "protocol.ErrorHolder", - "StackTraceElement": "protocol.StackTraceElement", - "MemberInfo": "core.MemberInfo", - "SimpleEntryView": "core.SimpleEntryView", - "RaftGroupId": "protocol.RaftGroupId", - "WanReplicationRef": "NA", - "HotRestartConfig": "NA", "EventJournalConfig": "NA", + "EvictionConfigHolder": "NA", + "HotRestartConfig": "NA", + "IndexConfig": "config.IndexConfig", + "Integer": "int32", + "List_CPMember": "NA", + "ListenerConfigHolder": "NA", + "Long": "int64", + "MapStoreConfigHolder": "NA", + "Map_EndpointQualifier_Address": "map[protocol.EndpointQualifier]core.Address", + "Map_String_String": "map[string]string", + "MemberInfo": "core.MemberInfo", + "MergePolicyConfig": "NA", "MerkleTreeConfig": "NA", - "TimedExpiryPolicyFactoryConfig": "NA", - "QueueStoreConfigHolder": "NA", - "RingbufferStoreConfigHolder": "NA", "NearCacheConfigHolder": "NA", - "EvictionConfigHolder": "NA", "NearCachePreloaderConfig": "NA", + "Pair": "serialization.Pair", "PredicateConfigHolder": "NA", - "DurationConfig": "NA", - - "MergePolicyConfig": "NA", - "CacheConfigHolder": "NA", - "CacheEventData": "NA", "QueryCacheConfigHolder": "NA", - "MapStoreConfigHolder": "NA", - "DistributedObjectInfo": "core.DistributedObjectInfo", - "IndexConfig": "config.IndexConfig", - "BitmapIndexOptions": "config.BitmapIndexOptions", - "AttributeConfig": "NA", - "ListenerConfigHolder": "NA", - "CacheSimpleEntryListenerConfig": "NA", - "ClientBwListEntry": "NA", - "EndpointQualifier": "protocol.EndpointQualifier", - - "Map_String_String": "map[string]string", - "Map_EndpointQualifier_Address": "map[protocol.EndpointQualifier]core.Address", - - "List_CPMember": "NA" + "QueueStoreConfigHolder": "NA", + "RaftGroupId": "protocol.RaftGroupId", + "RingbufferStoreConfigHolder": "NA", + "SimpleEntryView": "core.SimpleEntryView", + "StackTraceElement": "protocol.StackTraceElement", + "String": "string", + "TimedExpiryPolicyFactoryConfig": "NA", + "UUID": "core.UUID", + "WanReplicationRef": "NA", + "boolean": "bool", + "byte": "byte", + "byteArray": "[]byte", + "int": "int32", + "long": "int64", + "longArray": "[]int64", } _go_types_encode = { - "CacheEventData": "NA", - "QueryCacheEventData": "NA", - "ScheduledTaskHandler": "NA", - "Xid": "NA", - "ClientBwListEntry": "NA", - "MemberInfo": "core.MemberInfo", - "MemberVersion": "core.MemberVersion", - "MCEvent": "NA", "AnchorDataListHolder": "protocol.AnchorDataListHolder", - "PagingPredicateHolder": "protocol.PagingPredicateHolder", - "SqlQueryId": "NA", - "SqlError": "NA", - "SqlColumnMetadata": "NA", "CPMember": "NA", - "MigrationState": "NA", - - "List_Long": "[]int64", - "List_Integer": "[]int32", - "List_UUID": "[]core.UUID", - "List_String": "[]string", - "List_Xid": "NA", - "List_Data": "[]serialization.Data", - "List_List_Data": "[]serialization.Data", + "CacheEventData": "NA", + "ClientBwListEntry": "NA", + "EntryList_Data_Data": "[]protocol.Pair", + "EntryList_Data_List_Data": "[]protocol.Pair", + "EntryList_Integer_Integer": "[]protocol.Pair", + "EntryList_Integer_Long": "[]protocol.Pair", + "EntryList_Integer_UUID": "[]protocol.Pair", + "EntryList_Long_byteArray": "[]protocol.Pair", + "EntryList_String_EntryList_Integer_Long": "[]protocol.Pair", + "EntryList_String_String": "[]protocol.Pair", + "EntryList_String_byteArray": "[]protocol.Pair", + "EntryList_UUID_List_Integer": "[]protocol.Pair", + "EntryList_UUID_Long": "[]protocol.Pair", + "EntryList_UUID_UUID": "[]protocol.Pair", "ListCN_Data": "[]serialization.Data", - "List_ListCN_Data": "NA", - "List_MemberInfo": "[]core.MemberInfo", - "List_ScheduledTaskHandler": "NA", + "List_AttributeConfig": "NA", "List_CacheEventData": "NA", - "List_QueryCacheConfigHolder": "NA", + "List_CacheSimpleEntryListenerConfig": "NA", + "List_ClientBwListEntry": "NA", + "List_Data": "[]serialization.Data", "List_DistributedObjectInfo": "[]DistributedObjectInfo", - "List_QueryCacheEventData": "NA", "List_IndexConfig": "[]IndexConfig", - "List_AttributeConfig": "NA", + "List_Integer": "[]int32", + "List_ListCN_Data": "NA", + "List_List_Data": "[]serialization.Data", "List_ListenerConfigHolder": "NA", - "List_CacheSimpleEntryListenerConfig": "NA", - "List_StackTraceElement": "[]protocol.StackTraceElement", - "List_ClientBwListEntry": "NA", + "List_Long": "[]int64", "List_MCEvent": "NA", + "List_MemberInfo": "[]core.MemberInfo", + "List_QueryCacheConfigHolder": "NA", + "List_QueryCacheEventData": "NA", + "List_ScheduledTaskHandler": "NA", "List_SqlColumnMetadata": "NA", - - "EntryList_String_String": "[]protocol.Pair", - "EntryList_String_byteArray": "[]protocol.Pair", - "EntryList_Long_byteArray": "[]protocol.Pair", - "EntryList_Integer_UUID": "[]protocol.Pair", - "EntryList_Integer_Long": "[]protocol.Pair", - "EntryList_Integer_Integer": "[]protocol.Pair", - "EntryList_UUID_Long": "[]protocol.Pair", - "EntryList_String_EntryList_Integer_Long": "[]protocol.Pair", - "EntryList_UUID_UUID": "[]protocol.Pair", - "EntryList_UUID_List_Integer": "[]protocol.Pair", - "EntryList_Data_Data": "[]protocol.Pair", - "EntryList_Data_List_Data": "[]protocol.Pair", -} - -_go_types_decode = { - "CacheEventData": "NA", - "QueryCacheEventData": "NA", - "ScheduledTaskHandler": "NA", - "Xid": "NA", - "ClientBwListEntry": "NA", + "List_StackTraceElement": "[]protocol.StackTraceElement", + "List_String": "[]string", + "List_UUID": "[]core.UUID", + "List_Xid": "NA", + "MCEvent": "NA", "MemberInfo": "core.MemberInfo", "MemberVersion": "core.MemberVersion", - "MCEvent": "NA", - "AnchorDataListHolder": "protocol.AnchorDataListHolder", + "MigrationState": "NA", "PagingPredicateHolder": "protocol.PagingPredicateHolder", - "SqlQueryId": "NA", - "SqlError": "NA", + "QueryCacheEventData": "NA", + "ScheduledTaskHandler": "NA", "SqlColumnMetadata": "NA", - "CPMember": "NA", - "MigrationState": "NA", + "SqlError": "NA", + "SqlQueryId": "NA", + "Xid": "NA", +} - "List_Long": "[]int64", - "List_Integer": "[]int32", - "List_UUID": "[]core.UUID", - "List_Xid": "NA", - "List_String": "[]string", - "List_Data": "[]serialization.Data", - "List_List_Data": "[]serialization.Data", +_go_types_decode = { + "AnchorDataListHolder": "protocol.AnchorDataListHolder", + "CPMember": "NA", + "CacheEventData": "NA", + "ClientBwListEntry": "NA", + "EntryList_Data_Data": "[]protocol.Pair", + "EntryList_Data_List_Data": "[]protocol.Pair", + "EntryList_Integer_Integer": "[]protocol.Pair", + "EntryList_Integer_Long": "[]protocol.Pair", + "EntryList_Integer_UUID": "[]protocol.Pair", + "EntryList_Long_byteArray": "[]protocol.Pair", + "EntryList_String_EntryList_Integer_Long": "[]protocol.Pair", + "EntryList_String_String": "[]protocol.Pair", + "EntryList_String_byteArray": "[]protocol.Pair", + "EntryList_UUID_List_Integer": "[]protocol.Pair", + "EntryList_UUID_Long": "[]protocol.Pair", + "EntryList_UUID_UUID": "[]protocol.Pair", "ListCN_Data": "[]serialization.Data", - "List_ListCN_Data": "NA", - "List_MemberInfo": "[]core.MemberInfo", + "List_AttributeConfig": "NA", + "List_CPMember": "NA", "List_CacheEventData": "NA", - "List_QueryCacheConfigHolder": "NA", + "List_CacheSimpleEntryListenerConfig": "NA", + "List_ClientBwListEntry": "NA", + "List_Data": "[]serialization.Data", "List_DistributedObjectInfo": "[]core.DistributedObjectInfo", - "List_QueryCacheEventData": "NA", "List_IndexConfig": "[]IndexConfig", - "List_AttributeConfig": "NA", + "List_Integer": "[]int32", + "List_ListCN_Data": "NA", + "List_List_Data": "[]serialization.Data", "List_ListenerConfigHolder": "NA", - "List_CacheSimpleEntryListenerConfig": "NA", - "List_StackTraceElement": "[]protocol.StackTraceElement", - "List_ClientBwListEntry": "NA", + "List_Long": "[]int64", "List_MCEvent": "NA", + "List_MemberInfo": "[]core.MemberInfo", + "List_QueryCacheConfigHolder": "NA", + "List_QueryCacheEventData": "NA", "List_ScheduledTaskHandler": "NA", "List_SqlColumnMetadata": "NA", - "List_CPMember": "NA", - - "EntryList_String_String": "[]protocol.Pair", - "EntryList_String_byteArray": "[]protocol.Pair", - "EntryList_Long_byteArray": "[]protocol.Pair", - "EntryList_Integer_UUID": "[]protocol.Pair", - "EntryList_Integer_Long": "[]protocol.Pair", - "EntryList_Integer_Integer": "[]protocol.Pair", - "EntryList_UUID_Long": "[]protocol.Pair", - "EntryList_String_EntryList_Integer_Long": "[]protocol.Pair", - "EntryList_UUID_UUID": "[]protocol.Pair", - "EntryList_UUID_List_Integer": "[]protocol.Pair", - "EntryList_Data_Data": "[]protocol.Pair", - "EntryList_Data_List_Data": "[]protocol.Pair", + "List_StackTraceElement": "[]protocol.StackTraceElement", + "List_String": "[]string", + "List_UUID": "[]core.UUID", + "List_Xid": "NA", + "MCEvent": "NA", + "MemberInfo": "core.MemberInfo", + "MemberVersion": "core.MemberVersion", + "MigrationState": "NA", + "PagingPredicateHolder": "protocol.PagingPredicateHolder", + "QueryCacheEventData": "NA", + "ScheduledTaskHandler": "NA", + "SqlColumnMetadata": "NA", + "SqlError": "NA", + "SqlQueryId": "NA", + "Xid": "NA", } diff --git a/go/codec-template.go.j2 b/go/codec-template.go.j2 index 7459ef14d..65cfb2c75 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.go.j2 @@ -1,50 +1,40 @@ {% macro encode_var_sized(param, loop_last) -%} {% if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - internal.ListMultiFrameCodec.EncodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ escape_keyword(param.name) }}) + ListMultiFrameCodec.EncodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ escape_keyword(param.name) }}) {%- elif is_var_sized_entry_list(param.type) -%} - internal.EntryListCodec.EncodeFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}) + EntryListCodec.EncodeFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}) {%- elif is_var_sized_map(param.type) -%} - internal.MapCodec.Encode{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}, internal.{{ key_type(lang_name, param.type) }}Codec.Encode, internal.{{ value_type(lang_name, param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) + MapCodec.Encode{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}, Encode{{ key_type(lang_name, param.type) }}, Encode{{ value_type(lang_name, param.type) }}{% if loop_last %}, True{% endif %}) {%- else -%} {%- if param.nullable -%} - internal.CodecUtil.EncodeNullable(clientMessage, {{ param_name(param.name) }}, internal.{{ lang_name(param.type) }}Codec.Encode{% if loop_last %}, True{% endif %}) + CodecUtil.EncodeNullable(clientMessage, {{ param_name(param.name) }}, Encode{{ lang_name(param.type) }}{% if loop_last %}, True{% endif %}) {%- else -%} - internal.{{ lang_name(param.type) }}Codec.Encode(clientMessage, {{ param_name(param.name) }}{% if loop_last %}, True{% endif %}) + Encode{{ lang_name(param.type) }}(clientMessage, {{ param_name(param.name) }}{% if loop_last %}, True{% endif %}) {%- endif %} {% endif %} {%- endmacro %} {% macro decode_var_sized(param) -%} {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - internal.ListMultiFrameCodec.DecodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}{% if param.nullable %}_nullable{% endif %}(frameIterator) + ListMultiFrameCodec.DecodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}{% if param.nullable %}_nullable{% endif %}(frameIterator) {%- elif is_var_sized_entry_list(param.type) -%} - internal.EntryListCodec.DecodeFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}{% if param.nullable %}Nullable{% endif %}(frameIterator) + EntryListCodec.DecodeFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}{% if param.nullable %}Nullable{% endif %}(frameIterator) {%- elif is_var_sized_map(param.type) -%} - internal.MapCodec.Decode{% if param.nullable %}Nullable{% endif %}(v, internal.{{ key_type(lang_name, param.type) }}Codec.Decode, internal.{{ value_type(lang_name, param.type) }}Codec.Decode) + MapCodec.Decode{% if param.nullable %}Nullable{% endif %}(v, Decode{{ key_type(lang_name, param.type) }}, Decode{{ value_type(lang_name, param.type) }}) {%- else -%} {%- if param.nullable -%} - internal.CodecUtil.DecodeNullableFor{{ lang_name(param.type) }}(frameIterator) + CodecUtil.DecodeNullableFor{{ lang_name(param.type) }}(frameIterator) {%- else -%} - internal.{{ lang_name(param.type) }}Codec.Decode(frameIterator) + Decode{{ lang_name(param.type) }}(frameIterator) {%- endif -%} {%- endif -%} {%- endmacro %} - -{% macro get_import_statements() -%} - {% set imported_paths = [] %} - {%- for params in varargs -%} - {% for param in params %} - {% set path_holders = get_import_path_holders(param.type) %} - {% if path_holders is not none %} - {%- for path_holder in path_holders -%} - {% if not path_holder.path in imported_paths%} - {%- do imported_paths.append(path_holder.path) -%} - {{ path_holder.get_import_statement() }} - {% endif %} - {% endfor %} - {% endif %} - {%- endfor -%} - {%- endfor -%} -{%- endmacro %} +{% macro insert_import_statements(stmts) %} + "github.com/hazelcast/hazelcast-go-client/v4/internal/proto" + {% for stmt in stmts %} + {{ stmt }} + {% endfor %} +) +{% endmacro %} {% set request_fix_sized_params = fixed_params(method.request.params) %} {% set request_var_sized_params = var_size_params(method.request.params) %} {% set response_fix_sized_params = fixed_params(method.response.params) %} @@ -73,8 +63,16 @@ // limitations under the License. package codec -import ( -{{get_import_statements(request_fix_sized_params, request_var_sized_params, response_fix_sized_params, response_var_sized_params, event_fix_sized_params, event_var_sized_params)|indent(4, True)}}) +{{ insert_import_statements( + get_import_path_holders( + request_fix_sized_params, + request_var_sized_params, + response_fix_sized_params, + response_var_sized_params, + event_fix_sized_params, + event_var_sized_params + ) +)}} const( // hex: {{ '0x%06X'|format(method.request.id) }} @@ -89,23 +87,23 @@ const( {% endfor %} {#FIXED SIZED PARAMETER OFFSET CONSTANTS#} {% for param in request_fix_sized_params %} - {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset = {% if loop.first %}protocol.PartitionIDOffset + protocol.IntSizeInBytes{% else %}{{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ loop.previtem.name|capital }}Offset + protocol.{{ loop.previtem.type|capitalize }}SizeInBytes{% endif %} + {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset = {% if loop.first %}proto.PartitionIDOffset + proto.IntSizeInBytes{% else %}{{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ loop.previtem.name|capital }}Offset + proto.{{ loop.previtem.type|capitalize }}SizeInBytes{% endif %} {% if loop.last %} - {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize = {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset + protocol.{{ param.type|capitalize }}SizeInBytes + {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize = {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset + proto.{{ param.type|capitalize }}SizeInBytes {% endif %} {% else %} - {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize = protocol.PartitionIDOffset + protocol.IntSizeInBytes + {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes {% endfor %} {% for param in response_fix_sized_params %} - {{ service_name|capital }}{{ method.name|capital }}Response{{ param.name|capital }}Offset = {% if loop.first %}protocol.ResponseBackupAcksOffset + protocol.ByteSizeInBytes{% else %}{{ service_name|capital }}{{ method.name|capital }}Response{{ loop.previtem.name|capital }}Offset + protocol.{{ loop.previtem.type|capitalize }}SizeInBytes{% endif %} + {{ service_name|capital }}{{ method.name|capital }}Response{{ param.name|capital }}Offset = {% if loop.first %}proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes{% else %}{{ service_name|capital }}{{ method.name|capital }}Response{{ loop.previtem.name|capital }}Offset + proto.{{ loop.previtem.type|capitalize }}SizeInBytes{% endif %} {% endfor %} {% for event in method.events %} {% for param in fixed_params(event.params) %} - {{ service_name|capital }}{{ method.name|capital }}Event{{ event.name|capital }}{{param.name|capital}}Offset = {% if loop.first %}protocol.PartitionIDOffset + protocol.IntSizeInBytes{% else %}{{ service_name|capital }}{{ method.name|capital }}Event{{ event.name|capital }}{{ loop.previtem.name|capital }}Offset + protocol.{{loop.previtem.type|capitalize}}SizeInBytes{% endif %} + {{ service_name|capital }}{{ method.name|capital }}Event{{ event.name|capital }}{{param.name|capital}}Offset = {% if loop.first %}proto.PartitionIDOffset + proto.IntSizeInBytes{% else %}{{ service_name|capital }}{{ method.name|capital }}Event{{ event.name|capital }}{{ loop.previtem.name|capital }}Offset + proto.{{loop.previtem.type|capitalize}}SizeInBytes{% endif %} {% endfor %} {% endfor %} @@ -117,17 +115,14 @@ const( {% for line in method.doc.splitlines() %} // {{ line }} {% endfor %} -type {{ service_name|lower }}{{ method.name|capital }}Codec struct {} - -var {{ service_name|capital }}{{ method.name|capital }}Codec {{ service_name|lower }}{{ method.name|capital }}Codec -func ({{ service_name|lower }}{{ method.name|capital }}Codec) EncodeRequest({% for param in method.request.params %}{{ escape_keyword(param.name) }} {{ lang_types_encode(param.type) }}{% if not loop.last %}, {% endif %}{% endfor %}) *protocol.ClientMessage { - clientMessage := protocol.NewClientMessageForEncode() +func Encode{{ service_name|capital }}{{ method.name|capital }}Request({% for param in method.request.params %}{{ escape_keyword(param.name) }} {{ lang_types_encode(param.type) }}{% if not loop.last %}, {% endif %}{% endfor %}) *proto.ClientMessage { + clientMessage := proto.NewClientMessageForEncode() clientMessage.SetRetryable({{ method.request.retryable|lower }}) - initialFrame := protocol.NewFrame(make([]byte, {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize)) + initialFrame := proto.NewFrame(make([]byte, {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize)) {% for param in request_fix_sized_params %} - internal.FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset, {{ escape_keyword(param.name) }}) + FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset, {{ escape_keyword(param.name) }}) {% endfor %} clientMessage.AddFrame(initialFrame) clientMessage.SetMessageType({{ service_name|capital }}{{ method.name|capital }}CodecRequestMessageType) @@ -144,7 +139,7 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) EncodeRequest({% f {% if noResponseValue %} {% elif singleResponseValue %} {% set param = method.response.params|last %} -func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(clientMessage *protocol.ClientMessage) {{ lang_types_decode(param.type) }} { +func Decode{{ service_name|capital }}{{ method.name|capital }}Response(clientMessage *proto.ClientMessage) {{ lang_types_decode(param.type) }} { frameIterator := clientMessage.FrameIterator() {% if response_fix_sized_params|length != 0 %} initialFrame := frameIterator.Next() @@ -154,14 +149,14 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(cli {% endif %} {% for param in response_fix_sized_params %} - return internal.FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Response{{param.name|capital}}Offset) + return FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Response{{param.name|capital}}Offset) {% endfor %} {% for param in response_var_sized_params %} return {{ decode_var_sized(param) }} {% endfor %} } {% else %} -func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(clientMessage *protocol.ClientMessage) ({% for param in method.response.params %}{{ escape_keyword(param.name)}} {{ lang_types_encode(param.type) }}{{ ", " if not loop.last }}{% endfor %}{% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists: boolean;{% endfor %}) { +func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(clientMessage *proto.ClientMessage) ({% for param in method.response.params %}{{ escape_keyword(param.name)}} {{ lang_types_encode(param.type) }}{{ ", " if not loop.last }}{% endfor %}{% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists: boolean;{% endfor %}) { {% if response_fix_sized_params|length != 0 %} frameIterator := clientMessage.FrameIterator() initialFrame := frameIterator.Next() @@ -173,13 +168,13 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(cli {% for param in response_fix_sized_params %} {% if param in response_new_params %} if (initialFrame.content.length >= RESPONSE_{{ to_upper_snake_case(param.name) }}_OFFSET + BitsUtil.{{ param.type.upper() }}_SIZE_IN_BYTES) { - response.{{ escape_keyword(param.name) }} = internal.FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, RESPONSE_{{to_upper_snake_case(param.name)}}_OFFSET); + response.{{ escape_keyword(param.name) }} = FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, RESPONSE_{{to_upper_snake_case(param.name)}}_OFFSET); response.is{{ param.name|capital }}Exists = true; } else { response.is{{ param.name|capital }}Exists = false; } {% else %} - {{ escape_keyword(param.name) }} = internal.FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Response{{ param.name|capital }}Offset) + {{ escape_keyword(param.name) }} = FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Response{{ param.name|capital }}Offset) {% endif %} {% endfor %} {% for param in response_var_sized_params %} @@ -201,7 +196,7 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(cli {# EVENTS#} {% if method.events|length != 0 %} -func ({{ service_name|lower }}{{ method.name|capital }}Codec) Handle(clientMessage *protocol.ClientMessage, {% for event in method.events%}handle{{ event.name|capital }}Event func({% for param in event.params %}{% if param in new_event_params %}is{{ param.name|capital }}Exists, {% endif %}{{param.name}} {{ lang_types_encode(param.type) }}{% if not loop.last %}, {% endif %}{% endfor %}){% if not loop.last %}, {% endif %}{% endfor %}){ +func ({{ service_name|lower }}{{ method.name|capital }}Codec) Handle(clientMessage *proto.ClientMessage, {% for event in method.events%}handle{{ event.name|capital }}Event func({% for param in event.params %}{% if param in new_event_params %}is{{ param.name|capital }}Exists, {% endif %}{{param.name}} {{ lang_types_encode(param.type) }}{% if not loop.last %}, {% endif %}{% endfor %}){% if not loop.last %}, {% endif %}{% endfor %}){ messageType := clientMessage.GetMessageType() frameIterator := clientMessage.FrameIterator() {% for event in method.events%} @@ -222,7 +217,7 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) Handle(clientMessa is{{ param.name|capital }}Exists = true; } {% else %} - {{ escape_keyword(param.name) }} := internal.FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Event{{ event.name|capital }}{{param.name|capital}}Offset) + {{ escape_keyword(param.name) }} := FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Event{{ event.name|capital }}{{param.name|capital}}Offset) {% endif %} {% endfor %} {% for param in var_size_params(event.params) %} diff --git a/go/custom-codec-template.go.j2 b/go/custom-codec-template.go.j2 index bd57797f0..9ea7f4151 100644 --- a/go/custom-codec-template.go.j2 +++ b/go/custom-codec-template.go.j2 @@ -9,7 +9,7 @@ {%- if param.nullable -%} CodecUtil.EncodeNullableFor{{ lang_name(param.type) }}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}()) {%- else -%} - {{ lang_name(param.type) }}Codec.Encode(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}Is{% else %}Get{% endif %}{{ param.name|capital }}()) + Encode{{ lang_name(param.type) }}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}Is{% else %}Get{% endif %}{{ param.name|capital }}()) {%- endif %} {% endif %} {%- endmacro %} @@ -17,33 +17,25 @@ {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} ListMultiFrameCodec.DecodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(frameIterator) {%- elif is_var_sized_entry_list(param.type) -%} - EntryListCodec.Decode{% if param.nullable %}Nullable{% endif %}(frameIterator, {{ key_type(lang_name, param.type) }}Codec.Decode, {{ value_type(lang_name, param.type) }}Codec.DecodeNullable) + EntryListCodec.Decode{% if param.nullable %}Nullable{% endif %}(frameIterator, Decode{{ key_type(lang_name, param.type) }}, {{ value_type(lang_name, param.type) }}Codec.DecodeNullable) {%- elif is_var_sized_map(param.type) -%} MapCodec.DecodeFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}{% if param.nullable %}Nullable{% endif %}(frameIterator) {%- else -%} {%- if param.nullable -%} CodecUtil.DecodeNullableFor{{ lang_name(param.type) }}(frameIterator) {%- else -%} - {{ lang_name(param.type) }}Codec.Decode(frameIterator) + Decode{{ lang_name(param.type) }}(frameIterator) {%- endif -%} {%- endif -%} {%- endmacro %} -{% macro get_import_statements() -%} - {% set imported_paths = [] %} - {%- for params in varargs -%} - {% for param in params %} - {% set path_holders = get_import_path_holders(param.type) %} - {% if path_holders is not none %} - {%- for path_holder in path_holders -%} - {% if not path_holder.path in imported_paths %} - {%- do imported_paths.append(path_holder.path) -%} - {{ path_holder.get_import_statement() }} - {% endif %} - {% endfor %} - {% endif %} - {%- endfor -%} - {%- endfor -%} -{%- endmacro %} +{% macro insert_import_statements(stmts) %} +import ( + "github.com/hazelcast/hazelcast-go-client/v4/internal/proto" + {% for stmt in stmts %} + {{ stmt }} + {% endfor %} +) +{% endmacro %} {% set fix_sized_params = fixed_params(codec.params) %} {% set var_sized_params = var_size_params(codec.params) %} {% set new_codec_params = new_params(codec.since, codec.params) %} @@ -64,34 +56,40 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package internal +package codec -import ( -{{ get_import_statements(fix_sized_params, var_sized_params)|indent(4, True) }}) +{{ insert_import_statements( + get_import_path_holders( + fix_sized_params, + var_sized_params + ) +)}} {% if fix_sized_params|length > 0 %} const( {% for param in fix_sized_params %} - {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset = {% if loop.first %}0{% else %}{{ codec.name|capital }}Codec{{ loop.previtem.name|capital }}FieldOffset + protocol.{{ loop.previtem.type|capital }}SizeInBytes{% endif %} + {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset = {% if loop.first %}0{% else %}{{ codec.name|capital }}Codec{{ loop.previtem.name|capital }}FieldOffset + proto.{{ loop.previtem.type|capital }}SizeInBytes{% endif %} {% if loop.last %} - {{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize = {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset + protocol.{{ param.type|capital }}SizeInBytes + {{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize = {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset + proto.{{ param.type|capital }}SizeInBytes {% endif %} {% endfor %} ) {% endif %} +/* type {{ codec.name|lower }}Codec struct {} var {{ codec.name|capital }}Codec {{ codec.name|lower }}Codec +*/ -func ({{ codec.name|lower }}Codec) Encode(clientMessage *protocol.ClientMessage, {{ param_name(codec.name) }} {{ lang_types_encode(codec.name) }}){ +func Encode{{ codec.name|capital }}(clientMessage *proto.ClientMessage, {{ param_name(codec.name) }} {{ lang_types_encode(codec.name) }}){ {% if should_add_begin_frame %} - clientMessage.AddFrame(protocol.BeginFrame.Copy()) + clientMessage.AddFrame(proto.BeginFrame.Copy()) {% endif %} {% for param in fix_sized_params %} {% if loop.last %} - initialFrame := protocol.NewFrame(make([]byte,{{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize)) + initialFrame := proto.NewFrame(make([]byte,{{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize)) {% endif %} {% endfor %} {% for param in fix_sized_params %} @@ -117,10 +115,10 @@ func ({{ codec.name|lower }}Codec) Encode(clientMessage *protocol.ClientMessage, {{ encode_var_sized(param) }} {% endfor %} - clientMessage.AddFrame(protocol.EndFrame.Copy()) + clientMessage.AddFrame(proto.EndFrame.Copy()) } -func ({{ codec.name|lower }}Codec) Decode(frameIterator *protocol.ForwardFrameIterator) {{ lang_types_encode(codec.name) }} { +func Decode{{ codec.name|capital }}(frameIterator *proto.ForwardFrameIterator) {{ lang_types_encode(codec.name) }} { // begin frame {% if should_add_begin_frame %} frameIterator.Next() diff --git a/util.py b/util.py index c4ac97770..b943f1c15 100644 --- a/util.py +++ b/util.py @@ -11,7 +11,7 @@ from binary import FixedLengthTypes, FixedListTypes, FixedEntryListTypes, FixedMapTypes from java import java_types_encode, java_types_decode -from go import go_types_encode, go_types_decode, go_ignore_service_list, go_get_import_path_holders, go_escape_keyword +from go import go_types_encode, go_types_decode, go_ignore_service_list, go_get_import_statements, go_escape_keyword from cs import cs_types_encode, cs_types_decode, cs_escape_keyword, cs_ignore_service_list from cpp import cpp_types_encode, cpp_types_decode, cpp_ignore_service_list, get_size, is_trivial from ts import ts_types_encode, ts_types_decode, ts_escape_keyword, ts_ignore_service_list, ts_get_import_path_holders @@ -395,7 +395,7 @@ class SupportedLanguages(Enum): SupportedLanguages.CS: 'src/Hazelcast.Net/Protocol/CustomCodecs/', SupportedLanguages.PY: 'hazelcast/protocol/codec/custom/', SupportedLanguages.TS: 'src/codec/custom', - SupportedLanguages.GO: 'hazelcast/protocol/codec/internal' + SupportedLanguages.GO: 'hazelcast/protocol/codec' } @@ -467,7 +467,7 @@ def inner(*names): SupportedLanguages.CPP: lambda x: x, SupportedLanguages.TS: ts_get_import_path_holders, SupportedLanguages.PY: py_get_import_path_holders, - SupportedLanguages.GO: go_get_import_path_holders, + SupportedLanguages.GO: go_get_import_statements, # exposed as: get_import_path_holders } } From 985fd84869ffc657656a8c8bef9014ceae8eaa96 Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Wed, 24 Feb 2021 11:08:45 +0300 Subject: [PATCH 12/41] Go codec refactoring second stage - Added copy verbatim files step - builtin.go and builtin_test.go are copied verbatim - More Go generator refactoring --- generator.py | 2 + go/__init__.py | 92 ++-- go/codec-template.go.j2 | 1 + go/custom-codec-template.go.j2 | 29 +- go/verbatim/builtin.go | 753 +++++++++++++++++++++++++++++++++ go/verbatim/builtin_test.go | 619 +++++++++++++++++++++++++++ util.py | 19 + 7 files changed, 1460 insertions(+), 55 deletions(-) create mode 100644 go/verbatim/builtin.go create mode 100644 go/verbatim/builtin_test.go diff --git a/generator.py b/generator.py index d4eac8425..8ad74c700 100755 --- a/generator.py +++ b/generator.py @@ -111,6 +111,8 @@ print("Hazelcast Client Binary Protocol version %s" % (protocol_versions[-1])) env = create_environment(lang, namespace_arg) +copy_verbatim_files(codec_output_dir, lang_str_arg, env) + template_filename = env.get_template("codec-template.%s.j2" % lang_str_arg) codec_template = env.get_template(template_filename) diff --git a/go/__init__.py b/go/__init__.py index dfe414fa8..a3ad0ebcf 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -162,7 +162,7 @@ class PathHolders: } _go_types_common = { - "Address": "core.Address", + "Address": "proto.Address", "AttributeConfig": "NA", "BitmapIndexOptions": "config.BitmapIndexOptions", "CacheConfigHolder": "NA", @@ -170,10 +170,10 @@ class PathHolders: "CacheSimpleEntryListenerConfig": "NA", "ClientBwListEntry": "NA", "Data": "serialization.Data", - "DistributedObjectInfo": "core.DistributedObjectInfo", + "DistributedObjectInfo": "proto.DistributedObjectInfo", "DurationConfig": "NA", - "EndpointQualifier": "protocol.EndpointQualifier", - "ErrorHolder": "protocol.ErrorHolder", + "EndpointQualifier": "proto.EndpointQualifier", + "ErrorHolder": "proto.ErrorHolder", "EventJournalConfig": "NA", "EvictionConfigHolder": "NA", "HotRestartConfig": "NA", @@ -183,9 +183,9 @@ class PathHolders: "ListenerConfigHolder": "NA", "Long": "int64", "MapStoreConfigHolder": "NA", - "Map_EndpointQualifier_Address": "map[protocol.EndpointQualifier]core.Address", + "Map_EndpointQualifier_Address": "map[proto.EndpointQualifier]proto.Address", "Map_String_String": "map[string]string", - "MemberInfo": "core.MemberInfo", + "MemberInfo": "proto.MemberInfo", "MergePolicyConfig": "NA", "MerkleTreeConfig": "NA", "NearCacheConfigHolder": "NA", @@ -194,10 +194,10 @@ class PathHolders: "PredicateConfigHolder": "NA", "QueryCacheConfigHolder": "NA", "QueueStoreConfigHolder": "NA", - "RaftGroupId": "protocol.RaftGroupId", + "RaftGroupId": "proto.RaftGroupId", "RingbufferStoreConfigHolder": "NA", - "SimpleEntryView": "core.SimpleEntryView", - "StackTraceElement": "protocol.StackTraceElement", + "SimpleEntryView": "*core.SimpleEntryView", + "StackTraceElement": "proto.StackTraceElement", "String": "string", "TimedExpiryPolicyFactoryConfig": "NA", "UUID": "core.UUID", @@ -211,22 +211,22 @@ class PathHolders: } _go_types_encode = { - "AnchorDataListHolder": "protocol.AnchorDataListHolder", + "AnchorDataListHolder": "proto.AnchorDataListHolder", "CPMember": "NA", "CacheEventData": "NA", "ClientBwListEntry": "NA", - "EntryList_Data_Data": "[]protocol.Pair", - "EntryList_Data_List_Data": "[]protocol.Pair", - "EntryList_Integer_Integer": "[]protocol.Pair", - "EntryList_Integer_Long": "[]protocol.Pair", - "EntryList_Integer_UUID": "[]protocol.Pair", - "EntryList_Long_byteArray": "[]protocol.Pair", - "EntryList_String_EntryList_Integer_Long": "[]protocol.Pair", - "EntryList_String_String": "[]protocol.Pair", - "EntryList_String_byteArray": "[]protocol.Pair", - "EntryList_UUID_List_Integer": "[]protocol.Pair", - "EntryList_UUID_Long": "[]protocol.Pair", - "EntryList_UUID_UUID": "[]protocol.Pair", + "EntryList_Data_Data": "[]proto.Pair", + "EntryList_Data_List_Data": "[]proto.Pair", + "EntryList_Integer_Integer": "[]proto.Pair", + "EntryList_Integer_Long": "[]proto.Pair", + "EntryList_Integer_UUID": "[]proto.Pair", + "EntryList_Long_byteArray": "[]proto.Pair", + "EntryList_String_EntryList_Integer_Long": "[]proto.Pair", + "EntryList_String_String": "[]proto.Pair", + "EntryList_String_byteArray": "[]proto.Pair", + "EntryList_UUID_List_Integer": "[]proto.Pair", + "EntryList_UUID_Long": "[]proto.Pair", + "EntryList_UUID_UUID": "[]proto.Pair", "ListCN_Data": "[]serialization.Data", "List_AttributeConfig": "NA", "List_CacheEventData": "NA", @@ -241,20 +241,20 @@ class PathHolders: "List_ListenerConfigHolder": "NA", "List_Long": "[]int64", "List_MCEvent": "NA", - "List_MemberInfo": "[]core.MemberInfo", + "List_MemberInfo": "[]proto.MemberInfo", "List_QueryCacheConfigHolder": "NA", "List_QueryCacheEventData": "NA", "List_ScheduledTaskHandler": "NA", "List_SqlColumnMetadata": "NA", - "List_StackTraceElement": "[]protocol.StackTraceElement", + "List_StackTraceElement": "[]proto.StackTraceElement", "List_String": "[]string", "List_UUID": "[]core.UUID", "List_Xid": "NA", "MCEvent": "NA", - "MemberInfo": "core.MemberInfo", - "MemberVersion": "core.MemberVersion", + "MemberInfo": "proto.MemberInfo", + "MemberVersion": "proto.MemberVersion", "MigrationState": "NA", - "PagingPredicateHolder": "protocol.PagingPredicateHolder", + "PagingPredicateHolder": "proto.PagingPredicateHolder", "QueryCacheEventData": "NA", "ScheduledTaskHandler": "NA", "SqlColumnMetadata": "NA", @@ -264,22 +264,22 @@ class PathHolders: } _go_types_decode = { - "AnchorDataListHolder": "protocol.AnchorDataListHolder", + "AnchorDataListHolder": "proto.AnchorDataListHolder", "CPMember": "NA", "CacheEventData": "NA", "ClientBwListEntry": "NA", - "EntryList_Data_Data": "[]protocol.Pair", - "EntryList_Data_List_Data": "[]protocol.Pair", - "EntryList_Integer_Integer": "[]protocol.Pair", - "EntryList_Integer_Long": "[]protocol.Pair", - "EntryList_Integer_UUID": "[]protocol.Pair", - "EntryList_Long_byteArray": "[]protocol.Pair", - "EntryList_String_EntryList_Integer_Long": "[]protocol.Pair", - "EntryList_String_String": "[]protocol.Pair", - "EntryList_String_byteArray": "[]protocol.Pair", - "EntryList_UUID_List_Integer": "[]protocol.Pair", - "EntryList_UUID_Long": "[]protocol.Pair", - "EntryList_UUID_UUID": "[]protocol.Pair", + "EntryList_Data_Data": "[]proto.Pair", + "EntryList_Data_List_Data": "[]proto.Pair", + "EntryList_Integer_Integer": "[]proto.Pair", + "EntryList_Integer_Long": "[]proto.Pair", + "EntryList_Integer_UUID": "[]proto.Pair", + "EntryList_Long_byteArray": "[]proto.Pair", + "EntryList_String_EntryList_Integer_Long": "[]proto.Pair", + "EntryList_String_String": "[]proto.Pair", + "EntryList_String_byteArray": "[]proto.Pair", + "EntryList_UUID_List_Integer": "[]proto.Pair", + "EntryList_UUID_Long": "[]proto.Pair", + "EntryList_UUID_UUID": "[]proto.Pair", "ListCN_Data": "[]serialization.Data", "List_AttributeConfig": "NA", "List_CPMember": "NA", @@ -287,7 +287,7 @@ class PathHolders: "List_CacheSimpleEntryListenerConfig": "NA", "List_ClientBwListEntry": "NA", "List_Data": "[]serialization.Data", - "List_DistributedObjectInfo": "[]core.DistributedObjectInfo", + "List_DistributedObjectInfo": "[]proto.DistributedObjectInfo", "List_IndexConfig": "[]IndexConfig", "List_Integer": "[]int32", "List_ListCN_Data": "NA", @@ -295,20 +295,20 @@ class PathHolders: "List_ListenerConfigHolder": "NA", "List_Long": "[]int64", "List_MCEvent": "NA", - "List_MemberInfo": "[]core.MemberInfo", + "List_MemberInfo": "[]proto.MemberInfo", "List_QueryCacheConfigHolder": "NA", "List_QueryCacheEventData": "NA", "List_ScheduledTaskHandler": "NA", "List_SqlColumnMetadata": "NA", - "List_StackTraceElement": "[]protocol.StackTraceElement", + "List_StackTraceElement": "[]proto.StackTraceElement", "List_String": "[]string", "List_UUID": "[]core.UUID", "List_Xid": "NA", "MCEvent": "NA", - "MemberInfo": "core.MemberInfo", - "MemberVersion": "core.MemberVersion", + "MemberInfo": "proto.MemberInfo", + "MemberVersion": "proto.MemberVersion", "MigrationState": "NA", - "PagingPredicateHolder": "protocol.PagingPredicateHolder", + "PagingPredicateHolder": "proto.PagingPredicateHolder", "QueryCacheEventData": "NA", "ScheduledTaskHandler": "NA", "SqlColumnMetadata": "NA", diff --git a/go/codec-template.go.j2 b/go/codec-template.go.j2 index 65cfb2c75..e1065013d 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.go.j2 @@ -29,6 +29,7 @@ {%- endif -%} {%- endmacro %} {% macro insert_import_statements(stmts) %} +import ( "github.com/hazelcast/hazelcast-go-client/v4/internal/proto" {% for stmt in stmts %} {{ stmt }} diff --git a/go/custom-codec-template.go.j2 b/go/custom-codec-template.go.j2 index 9ea7f4151..da516fc21 100644 --- a/go/custom-codec-template.go.j2 +++ b/go/custom-codec-template.go.j2 @@ -1,15 +1,15 @@ {% macro encode_var_sized(param) -%} {% if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - ListMultiFrameCodec.EncodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}()) + ListMultiFrameCodec.EncodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}()) {%- elif is_var_sized_entry_list(param.type) -%} - EntryListCodec.EncodeFor{{ value_type(lang_name, param.type) }}And{{ key_type(lang_name, param.type) }}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}()) + EntryListCodec.EncodeFor{{ value_type(lang_name, param.type) }}And{{ key_type(lang_name, param.type) }}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}()) {%- elif is_var_sized_map(param.type) -%} - MapCodec.EncodeFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}()) + MapCodec.EncodeFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}{{ param.name|capital }}()) {%- else -%} {%- if param.nullable -%} - CodecUtil.EncodeNullableFor{{ lang_name(param.type) }}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}is{% else %}Get{% endif %}{{ param.name|capital }}()) + CodecUtil.EncodeNullableFor{{ lang_name(param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}()) {%- else -%} - Encode{{ lang_name(param.type) }}(clientMessage, {{ param_name(codec.name)}}.{% if param.type == 'boolean' %}Is{% else %}Get{% endif %}{{ param.name|capital }}()) + Encode{{ lang_name(param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}()) {%- endif %} {% endif %} {%- endmacro %} @@ -94,10 +94,18 @@ func Encode{{ codec.name|capital }}(clientMessage *proto.ClientMessage, {{ param {% endfor %} {% for param in fix_sized_params %} {% if escape_keyword(param.name).startswith('_') == true %} - FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset, {{ param_name(codec.name)}}.Get{{ escape_keyword(param.name)[1:]|capital }}()) + {% set keyword = escape_keyword(param.name)[1:] %} {% else %} - FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset, {{ param_name(codec.name)}}.Get{{ escape_keyword(param.name)|capital }}()) + {% set keyword = escape_keyword(param.name) %} {% endif %} + {% if param.type == "int" %} + {% set cast = "int32(" %} + {% elif param.type == "long" %} + {% set cast = "int64(" %} + {% else %} + {% set cast = "" %} + {% endif %} + FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset, {% if cast %}{{ cast }}{% endif %}{{ param_name(codec.name)}}.{{ keyword|capital }}(){% if cast %}){% endif %}) {% if loop.last %} {% if not should_add_begin_frame %} initialFrame.flags |= BEGIN_DATA_STRUCTURE_FLAG @@ -163,6 +171,9 @@ func Decode{{ codec.name|capital }}(frameIterator *proto.ForwardFrameIterator) { {% do ctor_params.append(param) %} {% endif %} {% endfor %} - - return {{ lang_types_encode(codec.name).split('.')[0] }}.New{{ lang_types_encode(codec.name).split('.')[1] }}({% for param in ctor_params %}{% if param in new_codec_params %}is{{ param.name|capital }}Exists, {% endif %}{{ escape_keyword(param.name) }}{% if not loop.last %}, {% endif %}{% endfor %}) + {% set encoded_codec_name = lang_types_encode(codec.name) %} + {% if encoded_codec_name.startswith("*") %} + {% set encoded_codec_name = encoded_codec_name[1:] %} + {% endif %} + return {{ encoded_codec_name.split('.')[0] }}.New{{ encoded_codec_name.split('.')[1] }}({% for param in ctor_params %}{% if param in new_codec_params %}is{{ param.name|capital }}Exists, {% endif %}{{ escape_keyword(param.name) }}{% if not loop.last %}, {% endif %}{% endfor %}) } diff --git a/go/verbatim/builtin.go b/go/verbatim/builtin.go new file mode 100644 index 000000000..c5d145126 --- /dev/null +++ b/go/verbatim/builtin.go @@ -0,0 +1,753 @@ +package codec + +import ( + "encoding/binary" + "strings" + + "github.com/hazelcast/hazelcast-go-client/v4/internal/core" + "github.com/hazelcast/hazelcast-go-client/v4/internal/proto" + "github.com/hazelcast/hazelcast-go-client/v4/internal/serialization/spi" + + "github.com/hazelcast/hazelcast-go-client/v4/internal/serialization" + + "github.com/hazelcast/hazelcast-go-client/v4/internal/config" +) + +// Encoder for ClientMessage and value +type Encoder func(message *proto.ClientMessage, value interface{}) + +// Decoder create serialization.Data +type Decoder func(frameIterator *proto.ForwardFrameIterator) serialization.Data + +// CodecUtil +type codecUtil struct{} + +var CodecUtil codecUtil + +func (codecUtil) FastForwardToEndFrame(frameIterator *proto.ForwardFrameIterator) { + numberOfExpectedEndFrames := 1 + var frame *proto.Frame + for numberOfExpectedEndFrames != 0 { + frame = frameIterator.Next() + if frame.IsEndFrame() { + numberOfExpectedEndFrames-- + } else if frame.IsBeginFrame() { + numberOfExpectedEndFrames++ + } + } +} + +func (codecUtil) EncodeNullable(message *proto.ClientMessage, value interface{}, encoder Encoder) { + if value == nil { + message.AddFrame(proto.NullFrame.Copy()) + } else { + encoder(message, value) + } +} + +func (codecUtil) EncodeNullableForString(message *proto.ClientMessage, value string) { + if strings.TrimSpace(value) == "" { + message.AddFrame(proto.NullFrame.Copy()) + } else { + EncodeString(message, value) + } +} + +func (codecUtil) EncodeNullableForBitmapIndexOptions(message *proto.ClientMessage, options *config.BitmapIndexOptions) { + if options == nil { + message.AddFrame(proto.NullFrame.Copy()) + } else { + EncodeBitmapIndexOptions(message, options) + } +} + +func (codecUtil) EncodeNullableForData(message *proto.ClientMessage, data serialization.Data) { + if data == nil { + message.AddFrame(proto.NullFrame.Copy()) + } else { + DataCodec.Encode(message, data) + } +} + +func (codecUtil) DecodeNullableForData(frameIterator *proto.ForwardFrameIterator) serialization.Data { + if CodecUtil.NextFrameIsNullFrame(frameIterator) { + return nil + } + return DataCodec.Decode(frameIterator) +} + +func (codecUtil) DecodeNullableForAddress(frameIterator *proto.ForwardFrameIterator) *proto.Address { + if CodecUtil.NextFrameIsNullFrame(frameIterator) { + return nil + } + addr := DecodeAddress(frameIterator) + return &addr +} + +func (codecUtil) DecodeNullableForLongArray(frameIterator *proto.ForwardFrameIterator) []int64 { + if CodecUtil.NextFrameIsNullFrame(frameIterator) { + return nil + } + return LongArrayCodec.Decode(frameIterator) +} + +func (codecUtil) DecodeNullableForString(frameIterator *proto.ForwardFrameIterator) string { + if CodecUtil.NextFrameIsNullFrame(frameIterator) { + return "" + } + return DecodeString(frameIterator) +} + +func (codecUtil) NextFrameIsDataStructureEndFrame(frameIterator *proto.ForwardFrameIterator) bool { + return frameIterator.PeekNext().IsEndFrame() +} + +func (codecUtil) NextFrameIsNullFrame(frameIterator *proto.ForwardFrameIterator) bool { + isNullFrame := frameIterator.PeekNext().IsNullFrame() + if isNullFrame { + frameIterator.Next() + } + return isNullFrame +} + +func (codecUtil) DecodeNullableForBitmapIndexOptions(frameIterator *proto.ForwardFrameIterator) *config.BitmapIndexOptions { + isNullFrame := frameIterator.PeekNext().IsNullFrame() + if isNullFrame { + frameIterator.Next() + } + return DecodeBitmapIndexOptions(frameIterator) +} + +func (codecUtil) DecodeNullableForSimpleEntryView(frameIterator *proto.ForwardFrameIterator) *core.SimpleEntryView { + isNullFrame := frameIterator.PeekNext().IsNullFrame() + if isNullFrame { + frameIterator.Next() + } + return DecodeSimpleEntryView(frameIterator) +} + +// ByteArrayCodec +type byteArrayCodec struct{} + +var ByteArrayCodec byteArrayCodec + +func (byteArrayCodec) Encode(message *proto.ClientMessage, value []byte) { + message.AddFrame(proto.NewFrame(value)) +} + +func (byteArrayCodec) Decode(frameIterator *proto.ForwardFrameIterator) []byte { + return frameIterator.Next().Content +} + +// DataCodec +type dataCodec struct{} + +var DataCodec dataCodec + +func (dataCodec) Encode(message *proto.ClientMessage, value interface{}) { + message.AddFrame(proto.NewFrame(value.(serialization.Data).ToByteArray())) +} + +func (dataCodec) EncodeNullable(message *proto.ClientMessage, data serialization.Data) { + if data == nil { + message.AddFrame(proto.NullFrame.Copy()) + } else { + message.AddFrame(proto.NewFrame(data.ToByteArray())) + } +} + +func (dataCodec) Decode(frameIterator *proto.ForwardFrameIterator) serialization.Data { + return spi.NewData(frameIterator.Next().Content) +} + +func (dataCodec) DecodeNullable(frameIterator *proto.ForwardFrameIterator) serialization.Data { + if CodecUtil.NextFrameIsNullFrame(frameIterator) { + return nil + } + return DataCodec.Decode(frameIterator) +} + +//EntryListCodec +type entryListCodec struct{} + +var EntryListCodec entryListCodec + +func (entryListCodec) Encode(message *proto.ClientMessage, entries []proto.Pair, keyEncoder, valueEncoder Encoder) { + message.AddFrame(proto.BeginFrame.Copy()) + for _, value := range entries { + keyEncoder(message, value.Key()) + valueEncoder(message, value.Value()) + } + message.AddFrame(proto.EndFrame.Copy()) +} + +func (entryListCodec) EncodeForStringAndString(message *proto.ClientMessage, entries []proto.Pair) { + message.AddFrame(proto.BeginFrame.Copy()) + for _, value := range entries { + EncodeString(message, value.Key()) + EncodeString(message, value.Value()) + } + message.AddFrame(proto.EndFrame.Copy()) +} + +func (entryListCodec) EncodeForStringAndByteArray(message *proto.ClientMessage, entries []proto.Pair) { + message.AddFrame(proto.BeginFrame.Copy()) + for _, value := range entries { + EncodeString(message, value.Key()) + ByteArrayCodec.Encode(message, value.Value().([]byte)) + } + message.AddFrame(proto.EndFrame.Copy()) + +} + +func (entryListCodec) EncodeForDataAndData(message *proto.ClientMessage, entries []proto.Pair) { + message.AddFrame(proto.BeginFrame.Copy()) + for _, value := range entries { + DataCodec.Encode(message, value.Key()) + DataCodec.Encode(message, value.Value()) + } + message.AddFrame(proto.EndFrame.Copy()) +} + +func (entryListCodec) EncodeForDataAndListData(message *proto.ClientMessage, entries []proto.Pair) { + message.AddFrame(proto.BeginFrame.Copy()) + for _, value := range entries { + DataCodec.Encode(message, value.Key()) + ListDataCodec.Encode(message, value.Value().([]serialization.Data)) + } + message.AddFrame(proto.EndFrame.Copy()) +} + +func (entryListCodec) EncodeNullable(message *proto.ClientMessage, entries []proto.Pair, keyEncoder, valueEncoder Encoder) { + if len(entries) == 0 { + message.AddFrame(proto.NullFrame.Copy()) + } else { + EntryListCodec.Encode(message, entries, keyEncoder, valueEncoder) + } +} + +func (entryListCodec) Decode(frameIterator *proto.ForwardFrameIterator, keyDecoder, valueDecoder Decoder) []proto.Pair { + result := make([]proto.Pair, 0) + frameIterator.Next() + for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { + key := keyDecoder(frameIterator) + value := valueDecoder(frameIterator) + result = append(result, proto.NewPair(key, value)) + } + frameIterator.Next() + return result +} + +func (entryListCodec) DecodeNullable(frameIterator *proto.ForwardFrameIterator, keyDecoder, valueDecoder Decoder) []proto.Pair { + if CodecUtil.NextFrameIsNullFrame(frameIterator) { + return nil + } + return EntryListCodec.Decode(frameIterator, keyDecoder, valueDecoder) +} + +func (entryListCodec) DecodeForStringAndEntryListIntegerLong(frameIterator *proto.ForwardFrameIterator) []proto.Pair { + result := make([]proto.Pair, 0) + frameIterator.Next() + for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { + key := DecodeString(frameIterator) + value := EntryListIntegerLongCodec.Decode(frameIterator) + result = append(result, proto.NewPair(key, value)) + } + frameIterator.Next() + return result +} + +func (entryListCodec) DecodeForDataAndData(frameIterator *proto.ForwardFrameIterator) []proto.Pair { + result := make([]proto.Pair, 0) + frameIterator.Next() + for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { + key := DataCodec.Decode(frameIterator) + value := DataCodec.Decode(frameIterator) + result = append(result, proto.NewPair(key, value)) + } + frameIterator.Next() + return result +} + +//EntryListIntegerIntegerCodec +type entryListIntegerIntegerCodec struct{} + +var EntryListIntegerIntegerCodec entryListIntegerIntegerCodec + +func (entryListIntegerIntegerCodec) EncodeListInteger(message *proto.ClientMessage, entries []proto.Pair) { + entryCount := len(entries) + frame := proto.NewFrame(make([]byte, entryCount*proto.EntrySizeInBytes)) + for i := 0; i < entryCount; i++ { + FixSizedTypesCodec.EncodeInt(frame.Content, int32(i*proto.EntrySizeInBytes), entries[i].Key().(int32)) + FixSizedTypesCodec.EncodeInt(frame.Content, int32(i*proto.EntrySizeInBytes+proto.IntSizeInBytes), entries[i].Value().(int32)) + } + message.AddFrame(frame) +} + +func (entryListIntegerIntegerCodec) Decode(frameIterator *proto.ForwardFrameIterator) []proto.Pair { + frame := frameIterator.Next() + itemCount := len(frame.Content) / proto.EntrySizeInBytes + result := make([]proto.Pair, itemCount) + for i := 0; i < itemCount; i++ { + key := FixSizedTypesCodec.DecodeInt(frame.Content, int32(i*proto.EntrySizeInBytes)) + value := FixSizedTypesCodec.DecodeInt(frame.Content, int32(i*proto.EntrySizeInBytes+proto.IntSizeInBytes)) + result = append(result, proto.NewPair(key, value)) + } + return result +} + +// EntryListUUIDLongCodec +type entryListUUIDLongCodec struct{} + +var EntryListUUIDLongCodec entryListUUIDLongCodec + +func (entryListUUIDLongCodec) Encode(message *proto.ClientMessage, entries []proto.Pair) { + size := len(entries) + content := make([]byte, size*proto.EntrySizeInBytes) + newFrame := proto.NewFrame(content) + for i, entry := range entries { + key := entry.Key().(core.UUID) + value := entry.Value().(int64) + FixSizedTypesCodec.EncodeUUID(content, int32(i*proto.EntrySizeInBytes), key) + FixSizedTypesCodec.EncodeLong(content, int32(i*proto.EntrySizeInBytes+proto.UUIDSizeInBytes), value) + } + message.AddFrame(newFrame) +} + +func (entryListUUIDLongCodec) Decode(frameIterator *proto.ForwardFrameIterator) []proto.Pair { + nextFrame := frameIterator.Next() + itemCount := len(nextFrame.Content) / proto.EntrySizeInBytes + content := make([]proto.Pair, itemCount) + for i := 0; i < itemCount; i++ { + uuid := FixSizedTypesCodec.DecodeUUID(nextFrame.Content, int32(i*proto.EntrySizeInBytes)) + value := FixSizedTypesCodec.DecodeLong(nextFrame.Content, int32(i*proto.EntrySizeInBytes+proto.UUIDSizeInBytes)) + content[i] = proto.NewPair(uuid, value) + } + return content +} + +// EntryListUUIDListIntegerCodec +type entryListUUIDListIntegerCodec struct{} + +var EntryListUUIDListIntegerCodec entryListUUIDListIntegerCodec + +func (entryListUUIDListIntegerCodec) Encode(message *proto.ClientMessage, entries []proto.Pair) { + entryCount := len(entries) + uuids := make([]core.UUID, entryCount) + message.AddFrame(proto.BeginFrame) + for i := 0; i < entryCount; i++ { + entry := entries[i] + key := entry.Key().(core.UUID) + value := entry.Value().([]int32) + uuids[i] = key + EncodeListInteger(message, value) + } + message.AddFrame(proto.EndFrame) + ListUUIDCodec.Encode(message, uuids) +} + +func (entryListUUIDListIntegerCodec) Decode(frameIterator *proto.ForwardFrameIterator) []proto.Pair { + values := ListMultiFrameCodec.DecodeWithListInteger(frameIterator) + keys := ListUUIDCodec.Decode(frameIterator) + keySize := len(keys) + result := make([]proto.Pair, keySize) + for i := 0; i < keySize; i++ { + result[i] = proto.NewPair(keys, values) + } + return result +} + +type entryListIntegerUUIDCodec struct{} + +var EntryListIntegerUUIDCodec entryListIntegerUUIDCodec + +func (entryListIntegerUUIDCodec) Decode(frameIterator *proto.ForwardFrameIterator) []proto.Pair { + frame := frameIterator.Next() + entryCount := len(frame.Content) / proto.EntrySizeInBytes + result := make([]proto.Pair, entryCount) + for i := 0; i < entryCount; i++ { + key := FixSizedTypesCodec.DecodeInt(frame.Content, int32(i*proto.EntrySizeInBytes)) + value := FixSizedTypesCodec.DecodeUUID(frame.Content, int32(i*proto.EntrySizeInBytes+proto.IntSizeInBytes)) + result[i] = proto.NewPair(key, value) + } + return result +} + +// entryListIntegerUUIDCodec +type entryListIntegerLongCodec struct{} + +var EntryListIntegerLongCodec entryListIntegerLongCodec + +func (entryListIntegerLongCodec) Decode(iterator *proto.ForwardFrameIterator) []proto.Pair { + frame := iterator.Next() + entryCount := len(frame.Content) / proto.EntrySizeInBytes + result := make([]proto.Pair, entryCount) + for i := 0; i < entryCount; i++ { + key := FixSizedTypesCodec.DecodeInt(frame.Content, int32(i*proto.EntrySizeInBytes)) + value := FixSizedTypesCodec.DecodeLong(frame.Content, int32(i*proto.EntrySizeInBytes+proto.IntSizeInBytes)) + result[i] = proto.NewPair(key, value) + } + return result +} + +// fixSizedTypesCodec +type fixSizedTypesCodec struct{} + +var FixSizedTypesCodec fixSizedTypesCodec + +func (fixSizedTypesCodec) EncodeInt(buffer []byte, offset, value int32) { + binary.LittleEndian.PutUint32(buffer[offset:], uint32(value)) +} + +func (fixSizedTypesCodec) DecodeInt(buffer []byte, offset int32) int32 { + return int32(binary.LittleEndian.Uint32(buffer[offset:])) +} + +func (fixSizedTypesCodec) EncodeLong(buffer []byte, offset int32, value int64) { + binary.LittleEndian.PutUint64(buffer[offset:], uint64(value)) +} + +func (fixSizedTypesCodec) DecodeLong(buffer []byte, offset int32) int64 { + return int64(binary.LittleEndian.Uint64(buffer[offset:])) +} + +func (fixSizedTypesCodec) EncodeBoolean(buffer []byte, offset int32, value bool) { + if value { + buffer[offset] = 1 + } else { + buffer[offset] = 0 + } +} + +func (fixSizedTypesCodec) DecodeBoolean(buffer []byte, offset int32) bool { + return buffer[offset] == 1 +} + +func (fixSizedTypesCodec) EncodeByte(buffer []byte, offset int32, value byte) { + buffer[offset] = value +} + +func (fixSizedTypesCodec) DecodeByte(buffer []byte, offset int32) byte { + return buffer[offset] +} + +func (fixSizedTypesCodec) EncodeUUID(buffer []byte, offset int32, uuid core.UUID) { + isNullEncode := uuid == nil + FixSizedTypesCodec.EncodeBoolean(buffer, offset, isNullEncode) + if isNullEncode { + return + } + bufferOffset := offset + proto.BooleanSizeInBytes + FixSizedTypesCodec.EncodeLong(buffer, bufferOffset, int64(uuid.GetMostSignificantBits())) + FixSizedTypesCodec.EncodeLong(buffer, bufferOffset+proto.LongSizeInBytes, int64(uuid.GetLeastSignificantBits())) +} + +func (fixSizedTypesCodec) DecodeUUID(buffer []byte, offset int32) core.UUID { + isNull := FixSizedTypesCodec.DecodeBoolean(buffer, offset) + if isNull { + return nil + } + + mostSignificantOffset := offset + proto.BooleanSizeInBytes + leastSignificantOffset := mostSignificantOffset + proto.LongSizeInBytes + mostSignificant := uint64(FixSizedTypesCodec.DecodeLong(buffer, mostSignificantOffset)) + leastSignificant := uint64(FixSizedTypesCodec.DecodeLong(buffer, leastSignificantOffset)) + + return core.NewUUIDWith(mostSignificant, leastSignificant) +} + +func EncodeListInteger(message *proto.ClientMessage, entries []int32) { + itemCount := len(entries) + content := make([]byte, itemCount*proto.IntSizeInBytes) + newFrame := proto.NewFrame(content) + for i := 0; i < itemCount; i++ { + FixSizedTypesCodec.EncodeInt(newFrame.Content, int32(i*proto.IntSizeInBytes), entries[i]) + } + message.AddFrame(newFrame) +} + +func DecodeListInteger(frameIterator *proto.ForwardFrameIterator) []int32 { + frame := frameIterator.Next() + itemCount := len(frame.Content) / proto.IntSizeInBytes + result := make([]int32, itemCount) + for i := 0; i < itemCount; i++ { + result[i] = FixSizedTypesCodec.DecodeInt(frame.Content, int32(i*proto.IntSizeInBytes)) + } + return result +} + +// ListLongCodec +type listLongCodec struct{} + +var ListLongCodec listLongCodec + +func (listLongCodec) Encode(message *proto.ClientMessage, entries []int64) { + itemCount := len(entries) + frame := proto.NewFrame(make([]byte, itemCount*proto.LongSizeInBytes)) + for i := 0; i < itemCount; i++ { + FixSizedTypesCodec.EncodeLong(frame.Content, int32(i*proto.LongSizeInBytes), entries[i]) + } + message.AddFrame(frame) +} + +func (listLongCodec) Decode(frameIterator *proto.ForwardFrameIterator) []int64 { + frame := frameIterator.Next() + itemCount := len(frame.Content) / proto.LongSizeInBytes + result := make([]int64, itemCount) + for i := 0; i < itemCount; i++ { + result[i] = FixSizedTypesCodec.DecodeLong(frame.Content, int32(i*proto.LongSizeInBytes)) + } + return result +} + +//ListMultiFrameCodec +type listMultiFrameCodec struct{} + +var ListMultiFrameCodec listMultiFrameCodec + +func (listMultiFrameCodec) Encode(message *proto.ClientMessage, values []serialization.Data, encoder Encoder) { + message.AddFrame(proto.BeginFrame) + for i := 0; i < len(values); i++ { + encoder(message, values[i]) + } + message.AddFrame(proto.EndFrame) +} + +func (listMultiFrameCodec) EncodeForData(message *proto.ClientMessage, values []serialization.Data) { + message.AddFrame(proto.BeginFrame) + for i := 0; i < len(values); i++ { + DataCodec.Encode(message, values[i]) + } + message.AddFrame(proto.EndFrame) +} + +func (c listMultiFrameCodec) EncodeForString(message *proto.ClientMessage, values []string) { + message.AddFrame(proto.BeginFrame) + for i := 0; i < len(values); i++ { + EncodeString(message, values[i]) + } + message.AddFrame(proto.EndFrame) +} + +func (c listMultiFrameCodec) EncodeForStackTraceElement(message *proto.ClientMessage, values []proto.StackTraceElement) { + message.AddFrame(proto.BeginFrame) + for i := 0; i < len(values); i++ { + EncodeStackTraceElement(message, values[i]) + } + message.AddFrame(proto.EndFrame) +} + +func (listMultiFrameCodec) EncodeContainsNullable(message *proto.ClientMessage, values []serialization.Data, encoder Encoder) { + message.AddFrame(proto.BeginFrame) + for i := 0; i < len(values); i++ { + if values[i] == nil { + message.AddFrame(proto.NullFrame) + } else { + encoder(message, values[i]) + } + } + message.AddFrame(proto.EndFrame) +} + +func (listMultiFrameCodec) EncodeNullable(message *proto.ClientMessage, values []serialization.Data, encoder Encoder) { + if len(values) == 0 { + message.AddFrame(proto.NullFrame) + } else { + ListMultiFrameCodec.Encode(message, values, encoder) + } +} + +func (listMultiFrameCodec) DecodeForData(frameIterator *proto.ForwardFrameIterator) []serialization.Data { + result := make([]serialization.Data, 0) + frameIterator.Next() + for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { + result = append(result, DataCodec.Decode(frameIterator)) + } + frameIterator.Next() + return result +} + +func (c listMultiFrameCodec) DecodeWithListInteger(frameIterator *proto.ForwardFrameIterator) []int32 { + result := make([]int32, 0) + frameIterator.Next() + for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { + result = append(result, DecodeListInteger(frameIterator)...) + } + frameIterator.Next() + return result +} + +func (c listMultiFrameCodec) DecodeForDistributedObjectInfo(frameIterator *proto.ForwardFrameIterator) []proto.DistributedObjectInfo { + result := make([]proto.DistributedObjectInfo, 0) + frameIterator.Next() + for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { + result = append(result, DecodeDistributedObjectInfo(frameIterator)) + } + frameIterator.Next() + return result +} + +func (c listMultiFrameCodec) DecodeForMemberInfo(frameIterator *proto.ForwardFrameIterator) []proto.MemberInfo { + result := make([]proto.MemberInfo, 0) + frameIterator.Next() + for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { + result = append(result, DecodeMemberInfo(frameIterator)) + } + frameIterator.Next() + return result +} + +func (listMultiFrameCodec) DecodeForStackTraceElement(frameIterator *proto.ForwardFrameIterator) []proto.StackTraceElement { + result := make([]proto.StackTraceElement, 0) + frameIterator.Next() + for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { + result = append(result, DecodeStackTraceElement(frameIterator)) + } + frameIterator.Next() + return result +} + +func (listMultiFrameCodec) DecodeForString(frameIterator *proto.ForwardFrameIterator) []string { + result := make([]string, 0) + frameIterator.Next() + for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { + result = append(result, DecodeString(frameIterator)) + } + frameIterator.Next() + return result +} + +func (listMultiFrameCodec) DecodeForDataContainsNullable(frameIterator *proto.ForwardFrameIterator) []serialization.Data { + result := make([]serialization.Data, 0) + frameIterator.Next() + for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { + if CodecUtil.NextFrameIsNullFrame(frameIterator) { + result = append(result, nil) + } else { + result = append(result, DataCodec.Decode(frameIterator)) + } + } + frameIterator.Next() + return result +} + +// listDataCodec +type listDataCodec struct{} + +var ListDataCodec listDataCodec + +func (listDataCodec) Encode(message *proto.ClientMessage, entries []serialization.Data) { + ListMultiFrameCodec.EncodeForData(message, entries) +} + +func (listDataCodec) Decode(frameIterator *proto.ForwardFrameIterator) []serialization.Data { + return ListMultiFrameCodec.DecodeForData(frameIterator) +} + +// listUUIDCodec +type listUUIDCodec struct{} + +var ListUUIDCodec listUUIDCodec + +func (listUUIDCodec) Encode(message *proto.ClientMessage, entries []core.UUID) { + itemCount := len(entries) + content := make([]byte, itemCount*proto.UUIDSizeInBytes) + newFrame := proto.NewFrame(content) + for i := 0; i < itemCount; i++ { + FixSizedTypesCodec.EncodeUUID(content, int32(i*proto.UUIDSizeInBytes), entries[i]) + } + message.AddFrame(newFrame) +} + +func (listUUIDCodec) Decode(frameIterator *proto.ForwardFrameIterator) []core.UUID { + frame := frameIterator.Next() + itemCount := len(frame.Content) / proto.UUIDSizeInBytes + result := make([]core.UUID, itemCount) + for i := 0; i < itemCount; i++ { + result[i] = FixSizedTypesCodec.DecodeUUID(frame.Content, int32(i*proto.UUIDSizeInBytes)) + } + return result +} + +// LongArrayCodec +type longArrayCodec struct{} + +var LongArrayCodec longArrayCodec + +func (longArrayCodec) Encode(message *proto.ClientMessage, entries []int64) { + itemCount := len(entries) + frame := proto.NewFrame(make([]byte, itemCount*proto.LongSizeInBytes)) + for i := 0; i < itemCount; i++ { + FixSizedTypesCodec.EncodeLong(frame.Content, int32(i*proto.LongSizeInBytes), entries[i]) + } + message.AddFrame(frame) +} + +func (longArrayCodec) Decode(frameIterator *proto.ForwardFrameIterator) []int64 { + frame := frameIterator.Next() + itemCount := len(frame.Content) / proto.LongSizeInBytes + result := make([]int64, itemCount) + for i := 0; i < itemCount; i++ { + result[i] = FixSizedTypesCodec.DecodeLong(frame.Content, int32(i*proto.LongSizeInBytes)) + } + return result +} + +// MapCodec +type mapCodec struct{} + +var MapCodec mapCodec + +func (mapCodec) EncodeForStringAndString(message *proto.ClientMessage, values map[string]string) { + message.AddFrame(proto.BeginFrame.Copy()) + for key, value := range values { + EncodeString(message, key) + EncodeString(message, value) + } + message.AddFrame(proto.EndFrame.Copy()) +} + +func (mapCodec) EncodeForEndpointQualifierAndAddress(message *proto.ClientMessage, values map[proto.EndpointQualifier]proto.Address) { + message.AddFrame(proto.BeginFrame.Copy()) + for key, value := range values { + EncodeEndpointQualifier(message, key) + EncodeAddress(message, value) + } + message.AddFrame(proto.EndFrame.Copy()) +} + +func (c mapCodec) DecodeForStringAndString(iterator *proto.ForwardFrameIterator) map[string]string { + result := map[string]string{} + + iterator.Next() + for !iterator.PeekNext().IsEndFrame() { + key := DecodeString(iterator) + value := DecodeString(iterator) + result[key] = value + } + iterator.Next() + + return result +} + +func (c mapCodec) DecodeForEndpointQualifierAndAddress(iterator *proto.ForwardFrameIterator) interface{} { + result := map[proto.EndpointQualifier]proto.Address{} + + iterator.Next() + for !iterator.PeekNext().IsEndFrame() { + key := DecodeEndpointQualifier(iterator) + value := DecodeAddress(iterator) + result[key] = value + } + iterator.Next() + + return result +} + +func EncodeString(message *proto.ClientMessage, value interface{}) { + message.AddFrame(proto.NewFrame([]byte(value.(string)))) +} + +func DecodeString(frameIterator *proto.ForwardFrameIterator) string { + return string(frameIterator.Next().Content) +} diff --git a/go/verbatim/builtin_test.go b/go/verbatim/builtin_test.go new file mode 100644 index 000000000..4ac1964f5 --- /dev/null +++ b/go/verbatim/builtin_test.go @@ -0,0 +1,619 @@ +package codec + +import ( + "encoding/binary" + "github.com/hazelcast/hazelcast-go-client/v4/internal/proto" + "testing" + + "github.com/hazelcast/hazelcast-go-client/v4/internal/core" + "github.com/stretchr/testify/assert" +) + +func TestCodecUtil_FastForwardToEndFrame(t *testing.T) { + // given + frame1 := proto.NewFrameWith([]byte("value-1"), proto.BeginDataStructureFlag) + frame2 := proto.NewFrameWith([]byte("value-2"), proto.EndDataStructureFlag) + frame3 := proto.NewFrameWith([]byte("value-3"), proto.EndDataStructureFlag) + + message := proto.NewClientMessage(frame1) + message.AddFrame(frame2) + message.AddFrame(frame3) + + //when + iterator := message.FrameIterator() + CodecUtil.FastForwardToEndFrame(iterator) + + //then + assert.False(t, iterator.HasNext()) + println(message.GetCorrelationID()) +} + +func TestCodecUtil_EncodeNullable(t *testing.T) { + //given + frame1 := proto.NewFrame([]byte("value-0")) + message := proto.NewClientMessage(frame1) + + //when + CodecUtil.EncodeNullable(message, "encode-value-1", StringCodec.Encode) + + //then + iterator := message.FrameIterator() + assert.Equal(t, string(iterator.Next().Content), "value-0") + assert.Equal(t, string(iterator.Next().Content), "encode-value-1") + assert.Equal(t, string(message.EndFrame.Content), "encode-value-1") +} + +func TestCodecUtil_NextFrameIsDataStructureEndFrame(t *testing.T) { + //given + byteValue := []byte("value-0") + flags := int32(proto.EndDataStructureFlag) + frame := proto.NewFrameWith(byteValue, flags) + message := proto.NewClientMessage(frame) + //when + frameIterator := message.FrameIterator() + isEndFrame := CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) + + //then + assert.True(t, isEndFrame) +} + +func TestCodecUtil_NextFrameIsNullFrame(t *testing.T) { + //given + nullFrame := proto.NullFrame + message := proto.NewClientMessage(nullFrame) + frame := proto.NewFrame([]byte("value-0")) + message.AddFrame(frame) + frameIterator := message.FrameIterator() + + //when + isNextFrameIsNull := CodecUtil.NextFrameIsNullFrame(frameIterator) + + //then + assert.True(t, isNextFrameIsNull) +} + +func TestCodecUtil_NextFrameIsNullFrame_Return_False_When_Next_Frame_Is_Not_Null(t *testing.T) { + //given + frame1 := proto.NewFrame([]byte("value-1")) + frame2 := proto.NewFrame([]byte("value-2")) + message := proto.NewClientMessage(frame1) + message.AddFrame(frame2) + frameIterator := message.FrameIterator() + + //when + isNextFrameIsNull := CodecUtil.NextFrameIsNullFrame(frameIterator) + + //then + assert.False(t, isNextFrameIsNull) +} + +func TestByteArrayCodec_Encode(t *testing.T) { + //given + value := []byte("value-1") + message := proto.NewClientMessageForEncode() + + //when + ByteArrayCodec.Encode(message, value) + + //then + iterator := message.FrameIterator() + assert.Equal(t, string(iterator.Next().Content), "value-1") +} + +func TestByteArrayCodec_Decode(t *testing.T) { + //given + value := []byte("value-1") + message := proto.NewClientMessage(proto.NewFrame(value)) + + //when + decode := ByteArrayCodec.Decode(message.FrameIterator()) + + //then + assert.Equal(t, string(decode), "value-1") +} + +func TestCodecUtil_EncodeNullable_If_Value_Is_Null_Add_Null_Frame_To_Message(t *testing.T) { + //given + frame1 := proto.NewFrame([]byte("value-0")) + message := proto.NewClientMessage(frame1) + + //when + CodecUtil.EncodeNullable(message, nil, StringCodec.Encode) + + //then + iterator := message.FrameIterator() + assert.Equal(t, string(iterator.Next().Content), "value-0") + assert.True(t, iterator.Next().IsNullFrame()) +} + +func TestDataCodec_EncodeNullable_When_Data_Is_Nil(t *testing.T) { + //given + message := proto.NewClientMessageForEncode() + + //when + DataCodec.EncodeNullable(message, nil) + + //then + iterator := message.FrameIterator() + assert.Len(t, iterator.Next().Content, 0) +} + +func TestDataCodec_Decode(t *testing.T) { + //given + bytes := []byte("value-0") + frame := proto.NewFrame(bytes) + message := proto.NewClientMessageForDecode(frame) + frameIterator := message.FrameIterator() + + //when + decode := DataCodec.Decode(frameIterator) + + //then + assert.Equal(t, decode.ToByteArray(), bytes) +} + +func TestDataCodec_Decode_When_Data_Is_Nil(t *testing.T) { + //given + nullFrame := proto.NullFrame + message := proto.NewClientMessage(nullFrame) + frameIterator := message.FrameIterator() + + //when + decode := DataCodec.DecodeNullable(frameIterator) + + //then + assert.Nil(t, decode) +} + +func TestEntryListCodec_Encode(t *testing.T) { + //given + bytes := []byte("value-0") + frame := proto.NewFrame(bytes) + message := proto.NewClientMessageForDecode(frame) + pairs := make([]proto.Pair, 0) + pairs = append(pairs, proto.NewPair("key", "value")) + + //when + EntryListCodec.Encode(message, pairs, StringCodec.Encode, StringCodec.Encode) + + //then + frameIterator := message.FrameIterator() + assert.Equal(t, string(frameIterator.Next().Content), "value-0") + + beginFrame := frameIterator.Next() + assert.Empty(t, beginFrame.Content) + assert.True(t, beginFrame.IsBeginFrame()) + + assert.Equal(t, string(frameIterator.Next().Content), "key") + assert.Equal(t, string(frameIterator.Next().Content), "value") + + endFrame := frameIterator.Next() + assert.Empty(t, endFrame.Content) + assert.True(t, endFrame.IsEndFrame()) +} + +func TestEntryListCodec_Encode_When_Entries_Is_Empty(t *testing.T) { + //given + bytes := []byte("value-0") + frame := proto.NewFrame(bytes) + message := proto.NewClientMessageForDecode(frame) + pairs := make([]proto.Pair, 0) + + //when + EntryListCodec.Encode(message, pairs, StringCodec.Encode, StringCodec.Encode) + + //then + frameIterator := message.FrameIterator() + assert.Equal(t, string(frameIterator.Next().Content), "value-0") + + beginFrame := frameIterator.Next() + assert.Empty(t, beginFrame.Content) + assert.True(t, beginFrame.IsBeginFrame()) + + endFrame := frameIterator.Next() + assert.Empty(t, endFrame.Content) + assert.True(t, endFrame.IsEndFrame()) +} + +func TestEntryListCodec_EncodeNullable(t *testing.T) { + //given + bytes := []byte("value-0") + frame := proto.NewFrame(bytes) + message := proto.NewClientMessageForDecode(frame) + pairs := make([]proto.Pair, 0) + pairs = append(pairs, proto.NewPair("key", "value")) + + //when + EntryListCodec.EncodeNullable(message, pairs, StringCodec.Encode, StringCodec.Encode) + + //then + frameIterator := message.FrameIterator() + assert.Equal(t, string(frameIterator.Next().Content), "value-0") + + beginFrame := frameIterator.Next() + assert.Empty(t, beginFrame.Content) + assert.True(t, beginFrame.IsBeginFrame()) + + assert.Equal(t, string(frameIterator.Next().Content), "key") + assert.Equal(t, string(frameIterator.Next().Content), "value") + + endFrame := frameIterator.Next() + assert.Empty(t, endFrame.Content) + assert.True(t, endFrame.IsEndFrame()) +} + +func TestEntryListCodec_EncodeNullable_When_Entries_Is_Empty(t *testing.T) { + //given + message := proto.NewClientMessageForEncode() + pairs := make([]proto.Pair, 0) + + //when + EntryListCodec.EncodeNullable(message, pairs, StringCodec.Encode, StringCodec.Encode) + + //then + frameIterator := message.FrameIterator() + assert.True(t, frameIterator.Next().IsNullFrame()) +} + +func TestEntryListCodec_DecodeNullable(t *testing.T) { + //given + nullFrame := proto.NullFrame + message := proto.NewClientMessageForDecode(nullFrame) + iterator := message.FrameIterator() + + //when + results := EntryListCodec.DecodeNullable(iterator, DataCodec.Decode, DataCodec.Decode) + + //then + assert.Nil(t, results) +} + +func TestEntryListCodec_DecodeNullable_When_Next_Frame_Is_Null_Frame(t *testing.T) { + //given + message := proto.NewClientMessageForDecode(proto.NullFrame) + iterator := message.FrameIterator() + + //when + results := EntryListCodec.DecodeNullable(iterator, DataCodec.Decode, DataCodec.Decode) + + //then + assert.Empty(t, results) +} + +func TestFixSizedTypesCodec_EncodeInt(t *testing.T) { + //given + buffer := make([]byte, 4) + offset := int32(0) + value := int32(100) + + //when + FixSizedTypesCodec.EncodeInt(buffer, offset, value) + + //then + assert.Equal(t, binary.LittleEndian.Uint32(buffer), uint32(100)) +} + +func TestFixSizedTypesCodec_DecodeInt(t *testing.T) { + //given + buffer := make([]byte, 4) + offset := int32(0) + value := int32(100) + FixSizedTypesCodec.EncodeInt(buffer, offset, value) + + //when + decodeInt := FixSizedTypesCodec.DecodeInt(buffer, offset) + + //then + assert.Equal(t, decodeInt, value) +} + +func TestFixSizedTypesCodec_EncodeLong(t *testing.T) { + //given + buffer := make([]byte, 8) + offset := int32(0) + value := int64(100000000000000000) + + //when + FixSizedTypesCodec.EncodeLong(buffer, offset, value) + + //then + assert.Equal(t, int64(binary.LittleEndian.Uint64(buffer[offset:])), value) +} + +func TestFixSizedTypesCodec_DecodeLong(t *testing.T) { + //given + buffer := make([]byte, 8) + offset := int32(0) + value := int64(100000000000000000) + FixSizedTypesCodec.EncodeLong(buffer, offset, value) + + //when + decodeLong := FixSizedTypesCodec.DecodeLong(buffer, offset) + + //then + assert.Equal(t, decodeLong, value) +} + +func TestFixSizedTypesCodec_EncodeBool(t *testing.T) { + //given + buffer := make([]byte, 1) + offset := int32(0) + + //when + FixSizedTypesCodec.EncodeBoolean(buffer, offset, true) + + //then + assert.True(t, buffer[offset] == 1) +} + +func TestFixSizedTypesCodec_EncodeBool_When_Value_Is_False(t *testing.T) { + //given + buffer := make([]byte, 1) + offset := int32(0) + + //when + FixSizedTypesCodec.EncodeBoolean(buffer, offset, false) + + //then + assert.True(t, buffer[offset] == 0) +} + +func TestFixSizedTypesCodec_EncodeByte(t *testing.T) { + //given + buffer := make([]byte, 1) + offset := int32(0) + + //when + FixSizedTypesCodec.EncodeByte(buffer, offset, 'b') + + //then + assert.Equal(t, string(buffer[0]), "b") +} + +func TestFixSizedTypesCodec_DecodeByte(t *testing.T) { + //given + buffer := make([]byte, 1) + offset := int32(0) + FixSizedTypesCodec.EncodeByte(buffer, offset, 'b') + + //when + decodeByte := FixSizedTypesCodec.DecodeByte(buffer, offset) + + //then + assert.Equal(t, string(decodeByte), "b") +} + +func TestFixSizedTypesCodec_EncodeUUID(t *testing.T) { + //given + buffer := make([]byte, proto.UUIDSizeInBytes) + offset := int32(0) + uuid := core.NewUUID() + + //when + FixSizedTypesCodec.EncodeUUID(buffer, offset, uuid) + + //then + assert.Equal(t, FixSizedTypesCodec.DecodeBoolean(buffer, offset), false) + assert.Equal(t, FixSizedTypesCodec.DecodeLong(buffer, offset+proto.BooleanSizeInBytes), int64(uuid.GetMostSignificantBits())) + assert.Equal(t, FixSizedTypesCodec.DecodeLong(buffer, offset+proto.BooleanSizeInBytes+proto.LongSizeInBytes), int64(uuid.GetLeastSignificantBits())) +} + +func TestFixSizedTypesCodec_EncodeUUID_When_UUID_Is_Nil(t *testing.T) { + //given + buffer := make([]byte, proto.UUIDSizeInBytes) + offset := int32(0) + + //when + FixSizedTypesCodec.EncodeUUID(buffer, offset, nil) + + //then + assert.Equal(t, FixSizedTypesCodec.DecodeBoolean(buffer, offset), true) +} + +func TestFixSizedTypesCodec_DecodeUUID(t *testing.T) { + //given + buffer := make([]byte, proto.UUIDSizeInBytes) + offset := int32(0) + uuid := core.NewUUID() + FixSizedTypesCodec.EncodeUUID(buffer, offset, uuid) + + //when + decodeUUID := FixSizedTypesCodec.DecodeUUID(buffer, offset) + + //then + assert.Equal(t, FixSizedTypesCodec.DecodeBoolean(buffer, offset), false) + assert.Equal(t, uuid.ToString(), decodeUUID.ToString()) + assert.Equal(t, uuid.GetMostSignificantBits(), decodeUUID.GetMostSignificantBits()) + assert.Equal(t, uuid.GetLeastSignificantBits(), decodeUUID.GetLeastSignificantBits()) +} + +func TestEntryListUUIDLongCodec_Encode(t *testing.T) { + // given + message := proto.NewClientMessageForEncode() + key := core.NewUUID() + value := int64(100) + pairs := make([]proto.Pair, 0) + pairs = append(pairs, proto.NewPair(key, value)) + EntryListUUIDLongCodec.Encode(message, pairs) + + // when + pairs = EntryListUUIDLongCodec.Decode(message.FrameIterator()) + + // then + frame := pairs[0] + assert.Equal(t, frame.Key().(core.UUID).ToString(), key.ToString()) + assert.Equal(t, frame.Value().(int64), value) +} + +func TestListUUIDCodec_Encode(t *testing.T) { + // given + message := proto.NewClientMessageForEncode() + entries := make([]core.UUID, 0) + value1 := core.NewUUID() + value2 := core.NewUUID() + entries = append(entries, value1, value2) + + // when + ListUUIDCodec.Encode(message, entries) + + // then + frame := message.FrameIterator().Next() + decodeUUID1 := FixSizedTypesCodec.DecodeUUID(frame.Content, 0) + assert.Equal(t, value1.ToString(), decodeUUID1.ToString()) + decodeUUID2 := FixSizedTypesCodec.DecodeUUID(frame.Content, 17) + assert.Equal(t, value2.ToString(), decodeUUID2.ToString()) +} + +func TestListIntegerCodec_Encode(t *testing.T) { + // given + clientMessage := proto.NewClientMessageForEncode() + entries := make([]int32, 0) + entries = append(entries, 1, 2, 3) + + // when + ListIntegerCodec.Encode(clientMessage, entries) + + // then + frame := clientMessage.FrameIterator().Next() + assert.Equal(t, FixSizedTypesCodec.DecodeInt(frame.Content, 0), int32(1)) + assert.Equal(t, FixSizedTypesCodec.DecodeInt(frame.Content, 4), int32(2)) + assert.Equal(t, FixSizedTypesCodec.DecodeInt(frame.Content, 8), int32(3)) +} + +func TestListIntegerCodec_Decode(t *testing.T) { + // given + clientMessage := proto.NewClientMessageForEncode() + entries := make([]int32, 0) + entries = append(entries, 1, 2, 3) + ListIntegerCodec.Encode(clientMessage, entries) + + // when + decodeEntries := ListIntegerCodec.Decode(clientMessage.FrameIterator()) + + // then + assert.Equal(t, decodeEntries[0], int32(1)) + assert.Equal(t, decodeEntries[1], int32(2)) + assert.Equal(t, decodeEntries[2], int32(3)) +} + +func TestListLongCodec_Encode(t *testing.T) { + // given + message := proto.NewClientMessageForEncode() + entries := make([]int64, 0) + entries = append(entries, 1, 2, 3) + + // when + ListLongCodec.Encode(message, entries) + + // then + frame := message.FrameIterator().Next() + assert.Equal(t, FixSizedTypesCodec.DecodeLong(frame.Content, 0), int64(1)) + assert.Equal(t, FixSizedTypesCodec.DecodeLong(frame.Content, 8), int64(2)) + assert.Equal(t, FixSizedTypesCodec.DecodeLong(frame.Content, 16), int64(3)) +} + +func TestListLongCodec_Decode(t *testing.T) { + // given + message := proto.NewClientMessageForEncode() + entries := make([]int64, 0) + entries = append(entries, 1, 2, 3) + ListLongCodec.Encode(message, entries) + + // when + result := ListLongCodec.Decode(message.FrameIterator()) + + // then + assert.Equal(t, result, entries) +} + +func TestEntryListUUIDListIntegerCodec_Encode(t *testing.T) { + // given + clientMessage := proto.NewClientMessageForEncode() + key := core.NewUUID() + value := make([]int32, 0) + value = append(value, 1, 2, 3) + pair := proto.NewPair(key, value) + entries := make([]proto.Pair, 0) + entries = append(entries, pair) + + // when + EntryListUUIDListIntegerCodec.Encode(clientMessage, entries) + + // then + iterator := clientMessage.FrameIterator() + assert.Equal(t, iterator.Next().IsBeginFrame(), true) + integerValues := iterator.Next() + assert.Equal(t, FixSizedTypesCodec.DecodeInt(integerValues.Content, 0), int32(1)) + assert.Equal(t, FixSizedTypesCodec.DecodeInt(integerValues.Content, 4), int32(2)) + assert.Equal(t, FixSizedTypesCodec.DecodeInt(integerValues.Content, 8), int32(3)) + assert.Equal(t, iterator.Next().IsEndFrame(), true) + uuid := FixSizedTypesCodec.DecodeUUID(iterator.Next().Content, 0) + assert.Equal(t, uuid.ToString(), key.ToString()) +} + +func TestEntryListUUIDListIntegerCodec_Decode(t *testing.T) { + // given + clientMessage := proto.NewClientMessageForEncode() + key := core.NewUUID() + value := make([]int32, 0) + value = append(value, 1, 2, 3) + pair := proto.NewPair(key, value) + entries := make([]proto.Pair, 0) + entries = append(entries, pair) + EntryListUUIDListIntegerCodec.Encode(clientMessage, entries) + + // when + result := EntryListUUIDListIntegerCodec.Decode(clientMessage.FrameIterator()) + + // then + assert.Equal(t, len(result), 1) + assert.Equal(t, result[0].Key().([]core.UUID)[0].ToString(), key.ToString()) + assert.EqualValues(t, result[0].Value().([]int32), value) +} + +func TestLongArrayCodec_Encode(t *testing.T) { + // given + clientMessage := proto.NewClientMessageForEncode() + entries := make([]int64, 0) + entries = append(entries, 1, 2, 3) + + // when + LongArrayCodec.Encode(clientMessage, entries) + + // then + frame := clientMessage.FrameIterator().Next() + assert.Equal(t, FixSizedTypesCodec.DecodeLong(frame.Content, 0), int64(1)) + assert.Equal(t, FixSizedTypesCodec.DecodeLong(frame.Content, 8), int64(2)) + assert.Equal(t, FixSizedTypesCodec.DecodeLong(frame.Content, 16), int64(3)) +} + +func TestLongArrayCodec_Decode(t *testing.T) { + // given + clientMessage := proto.NewClientMessageForEncode() + entries := make([]int64, 0) + entries = append(entries, 1, 2, 3) + LongArrayCodec.Encode(clientMessage, entries) + + // when + result := LongArrayCodec.Decode(clientMessage.FrameIterator()) + + // then + assert.Equal(t, result[0], int64(1)) + assert.Equal(t, result[1], int64(2)) + assert.Equal(t, result[2], int64(3)) +} + +func TestStringCodec_Encode(t *testing.T) { + //given + + value := "value-encode" + frame := proto.NewFrame([]byte("")) + clientMessage := proto.NewClientMessage(frame) + + //when + StringCodec.Encode(clientMessage, value) + + //then + content := clientMessage.EndFrame.Content + assert.Equal(t, value, string(content)) +} diff --git a/util.py b/util.py index b943f1c15..9aa347e50 100644 --- a/util.py +++ b/util.py @@ -1,5 +1,7 @@ import hashlib import json +import shutil + import jsonschema import os import re @@ -371,6 +373,23 @@ def get_protocol_versions(protocol_defs, custom_codec_defs): return map(str, protocol_versions) +def copy_verbatim_files(output_dir, lang, env): + cur_dir = os.path.dirname(os.path.realpath(__file__)) + lang_dir = os.path.join(cur_dir, lang) + verbatim_dir = os.path.join(lang_dir, "verbatim") + if not os.path.exists(verbatim_dir): + return + # iterate the verbatim directory and copy files to output + # creating directories if necessary + print("Verbatim files found, copying from %s to %s" % (verbatim_dir, output_dir)) + shutil.copytree( + verbatim_dir, + output_dir, + ignore=shutil.ignore_patterns(".*"), + dirs_exist_ok=True + ) + + class SupportedLanguages(Enum): JAVA = 'java' CPP = 'cpp' From 965b5889e6dcc6e518882172e23b79b0f3afbc4e Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Wed, 24 Feb 2021 17:44:50 +0300 Subject: [PATCH 13/41] More Go generator updates --- go/codec-template.go.j2 | 12 +- go/custom-codec-template.go.j2 | 12 +- go/verbatim/builtin.go | 240 +++++++++++++-------------------- 3 files changed, 108 insertions(+), 156 deletions(-) diff --git a/go/codec-template.go.j2 b/go/codec-template.go.j2 index e1065013d..90f18bb81 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.go.j2 @@ -1,10 +1,10 @@ {% macro encode_var_sized(param, loop_last) -%} {% if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - ListMultiFrameCodec.EncodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ escape_keyword(param.name) }}) + Encode{% if param.nullable %}Nullable{% endif %}ListMultiFrame{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}For{{ item_type(lang_name, param.type) }}(clientMessage, {{ escape_keyword(param.name) }}) {%- elif is_var_sized_entry_list(param.type) -%} - EntryListCodec.EncodeFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}) + Encode{% if param.nullable %}Nullable{% endif %}EntryListFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}(clientMessage, {{ param_name(param.name) }}) {%- elif is_var_sized_map(param.type) -%} - MapCodec.Encode{% if param.nullable %}_nullable{% endif %}(clientMessage, {{ param_name(param.name) }}, Encode{{ key_type(lang_name, param.type) }}, Encode{{ value_type(lang_name, param.type) }}{% if loop_last %}, True{% endif %}) + Encode{% if param.nullable %}Nullable{% endif %}Map(clientMessage, {{ param_name(param.name) }}, Encode{{ key_type(lang_name, param.type) }}, Encode{{ value_type(lang_name, param.type) }}{% if loop_last %}, True{% endif %}) {%- else -%} {%- if param.nullable -%} CodecUtil.EncodeNullable(clientMessage, {{ param_name(param.name) }}, Encode{{ lang_name(param.type) }}{% if loop_last %}, True{% endif %}) @@ -15,11 +15,11 @@ {%- endmacro %} {% macro decode_var_sized(param) -%} {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - ListMultiFrameCodec.DecodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}{% if param.nullable %}_nullable{% endif %}(frameIterator) + Decode{% if param.nullable %}Nullable{% endif %}ListMultiFrameFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}(frameIterator) {%- elif is_var_sized_entry_list(param.type) -%} - EntryListCodec.DecodeFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}{% if param.nullable %}Nullable{% endif %}(frameIterator) + Decode{% if param.nullable %}Nullable{% endif %}EntryListFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}(frameIterator) {%- elif is_var_sized_map(param.type) -%} - MapCodec.Decode{% if param.nullable %}Nullable{% endif %}(v, Decode{{ key_type(lang_name, param.type) }}, Decode{{ value_type(lang_name, param.type) }}) + Decode{% if param.nullable %}Nullable{% endif %}Map(v, Decode{{ key_type(lang_name, param.type) }}, Decode{{ value_type(lang_name, param.type) }}) {%- else -%} {%- if param.nullable -%} CodecUtil.DecodeNullableFor{{ lang_name(param.type) }}(frameIterator) diff --git a/go/custom-codec-template.go.j2 b/go/custom-codec-template.go.j2 index da516fc21..4ff15ac31 100644 --- a/go/custom-codec-template.go.j2 +++ b/go/custom-codec-template.go.j2 @@ -1,10 +1,10 @@ {% macro encode_var_sized(param) -%} {% if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - ListMultiFrameCodec.EncodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}()) + Encode{% if param.nullable %}Nullable{% endif %}ListMultiFrame{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}For{{ item_type(lang_name, param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}()) {%- elif is_var_sized_entry_list(param.type) -%} - EntryListCodec.EncodeFor{{ value_type(lang_name, param.type) }}And{{ key_type(lang_name, param.type) }}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}()) + Encode{% if param.nullable %}Nullable{% endif %}EntryListFor{{ value_type(lang_name, param.type) }}And{{ key_type(lang_name, param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}()) {%- elif is_var_sized_map(param.type) -%} - MapCodec.EncodeFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}{% if param.nullable %}Nullable{% endif %}(clientMessage, {{ param_name(codec.name)}}{{ param.name|capital }}()) + Encode{% if param.nullable %}Nullable{% endif %}MapFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}()) {%- else -%} {%- if param.nullable -%} CodecUtil.EncodeNullableFor{{ lang_name(param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}()) @@ -15,11 +15,11 @@ {%- endmacro %} {% macro decode_var_sized(param) -%} {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - ListMultiFrameCodec.DecodeFor{{ item_type(lang_name, param.type) }}{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}{% if param.nullable %}Nullable{% endif %}(frameIterator) + Decode{% if param.nullable %}Nullable{% endif %}ListMultiFrame{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}For{{ item_type(lang_name, param.type) }}(frameIterator) {%- elif is_var_sized_entry_list(param.type) -%} - EntryListCodec.Decode{% if param.nullable %}Nullable{% endif %}(frameIterator, Decode{{ key_type(lang_name, param.type) }}, {{ value_type(lang_name, param.type) }}Codec.DecodeNullable) + Decode{% if param.nullable %}Nullable{% endif %}EntryList(frameIterator, Decode{{ key_type(lang_name, param.type) }}, DecodeNullable{{ value_type(lang_name, param.type) }}) {%- elif is_var_sized_map(param.type) -%} - MapCodec.DecodeFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}{% if param.nullable %}Nullable{% endif %}(frameIterator) + Decode{% if param.nullable %}Nullable{% endif %}MapFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}(frameIterator) {%- else -%} {%- if param.nullable -%} CodecUtil.DecodeNullableFor{{ lang_name(param.type) }}(frameIterator) diff --git a/go/verbatim/builtin.go b/go/verbatim/builtin.go index c5d145126..53792f28a 100644 --- a/go/verbatim/builtin.go +++ b/go/verbatim/builtin.go @@ -65,7 +65,7 @@ func (codecUtil) EncodeNullableForData(message *proto.ClientMessage, data serial if data == nil { message.AddFrame(proto.NullFrame.Copy()) } else { - DataCodec.Encode(message, data) + EncodeData(message, data) } } @@ -73,7 +73,7 @@ func (codecUtil) DecodeNullableForData(frameIterator *proto.ForwardFrameIterator if CodecUtil.NextFrameIsNullFrame(frameIterator) { return nil } - return DataCodec.Decode(frameIterator) + return DecodeData(frameIterator) } func (codecUtil) DecodeNullableForAddress(frameIterator *proto.ForwardFrameIterator) *proto.Address { @@ -88,7 +88,7 @@ func (codecUtil) DecodeNullableForLongArray(frameIterator *proto.ForwardFrameIte if CodecUtil.NextFrameIsNullFrame(frameIterator) { return nil } - return LongArrayCodec.Decode(frameIterator) + return DecodeLongArray(frameIterator) } func (codecUtil) DecodeNullableForString(frameIterator *proto.ForwardFrameIterator) string { @@ -126,29 +126,19 @@ func (codecUtil) DecodeNullableForSimpleEntryView(frameIterator *proto.ForwardFr return DecodeSimpleEntryView(frameIterator) } -// ByteArrayCodec -type byteArrayCodec struct{} - -var ByteArrayCodec byteArrayCodec - -func (byteArrayCodec) Encode(message *proto.ClientMessage, value []byte) { +func EncodeByteArray(message *proto.ClientMessage, value []byte) { message.AddFrame(proto.NewFrame(value)) } -func (byteArrayCodec) Decode(frameIterator *proto.ForwardFrameIterator) []byte { +func DecodeByteArray(frameIterator *proto.ForwardFrameIterator) []byte { return frameIterator.Next().Content } -// DataCodec -type dataCodec struct{} - -var DataCodec dataCodec - -func (dataCodec) Encode(message *proto.ClientMessage, value interface{}) { +func EncodeData(message *proto.ClientMessage, value interface{}) { message.AddFrame(proto.NewFrame(value.(serialization.Data).ToByteArray())) } -func (dataCodec) EncodeNullable(message *proto.ClientMessage, data serialization.Data) { +func EncodeNullableData(message *proto.ClientMessage, data serialization.Data) { if data == nil { message.AddFrame(proto.NullFrame.Copy()) } else { @@ -156,23 +146,18 @@ func (dataCodec) EncodeNullable(message *proto.ClientMessage, data serialization } } -func (dataCodec) Decode(frameIterator *proto.ForwardFrameIterator) serialization.Data { +func DecodeData(frameIterator *proto.ForwardFrameIterator) serialization.Data { return spi.NewData(frameIterator.Next().Content) } -func (dataCodec) DecodeNullable(frameIterator *proto.ForwardFrameIterator) serialization.Data { +func DecodeNullableData(frameIterator *proto.ForwardFrameIterator) serialization.Data { if CodecUtil.NextFrameIsNullFrame(frameIterator) { return nil } - return DataCodec.Decode(frameIterator) + return DecodeData(frameIterator) } -//EntryListCodec -type entryListCodec struct{} - -var EntryListCodec entryListCodec - -func (entryListCodec) Encode(message *proto.ClientMessage, entries []proto.Pair, keyEncoder, valueEncoder Encoder) { +func EncodeEntryList(message *proto.ClientMessage, entries []proto.Pair, keyEncoder, valueEncoder Encoder) { message.AddFrame(proto.BeginFrame.Copy()) for _, value := range entries { keyEncoder(message, value.Key()) @@ -181,7 +166,7 @@ func (entryListCodec) Encode(message *proto.ClientMessage, entries []proto.Pair, message.AddFrame(proto.EndFrame.Copy()) } -func (entryListCodec) EncodeForStringAndString(message *proto.ClientMessage, entries []proto.Pair) { +func EncodeEntryListForStringAndString(message *proto.ClientMessage, entries []proto.Pair) { message.AddFrame(proto.BeginFrame.Copy()) for _, value := range entries { EncodeString(message, value.Key()) @@ -190,43 +175,43 @@ func (entryListCodec) EncodeForStringAndString(message *proto.ClientMessage, ent message.AddFrame(proto.EndFrame.Copy()) } -func (entryListCodec) EncodeForStringAndByteArray(message *proto.ClientMessage, entries []proto.Pair) { +func EncodeEntryListForStringAndByteArray(message *proto.ClientMessage, entries []proto.Pair) { message.AddFrame(proto.BeginFrame.Copy()) for _, value := range entries { EncodeString(message, value.Key()) - ByteArrayCodec.Encode(message, value.Value().([]byte)) + EncodeByteArray(message, value.Value().([]byte)) } message.AddFrame(proto.EndFrame.Copy()) } -func (entryListCodec) EncodeForDataAndData(message *proto.ClientMessage, entries []proto.Pair) { +func EncodeEntryListForDataAndData(message *proto.ClientMessage, entries []proto.Pair) { message.AddFrame(proto.BeginFrame.Copy()) for _, value := range entries { - DataCodec.Encode(message, value.Key()) - DataCodec.Encode(message, value.Value()) + EncodeData(message, value.Key()) + EncodeData(message, value.Value()) } message.AddFrame(proto.EndFrame.Copy()) } -func (entryListCodec) EncodeForDataAndListData(message *proto.ClientMessage, entries []proto.Pair) { +func EncodeEntryListForDataAndListData(message *proto.ClientMessage, entries []proto.Pair) { message.AddFrame(proto.BeginFrame.Copy()) for _, value := range entries { - DataCodec.Encode(message, value.Key()) - ListDataCodec.Encode(message, value.Value().([]serialization.Data)) + EncodeData(message, value.Key()) + EncodeListData(message, value.Value().([]serialization.Data)) } message.AddFrame(proto.EndFrame.Copy()) } -func (entryListCodec) EncodeNullable(message *proto.ClientMessage, entries []proto.Pair, keyEncoder, valueEncoder Encoder) { +func EncodeNullableEntryList(message *proto.ClientMessage, entries []proto.Pair, keyEncoder, valueEncoder Encoder) { if len(entries) == 0 { message.AddFrame(proto.NullFrame.Copy()) } else { - EntryListCodec.Encode(message, entries, keyEncoder, valueEncoder) + EncodeEntryList(message, entries, keyEncoder, valueEncoder) } } -func (entryListCodec) Decode(frameIterator *proto.ForwardFrameIterator, keyDecoder, valueDecoder Decoder) []proto.Pair { +func DecodeEntryList(frameIterator *proto.ForwardFrameIterator, keyDecoder, valueDecoder Decoder) []proto.Pair { result := make([]proto.Pair, 0) frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { @@ -238,43 +223,38 @@ func (entryListCodec) Decode(frameIterator *proto.ForwardFrameIterator, keyDecod return result } -func (entryListCodec) DecodeNullable(frameIterator *proto.ForwardFrameIterator, keyDecoder, valueDecoder Decoder) []proto.Pair { +func DecodeNullableEntryList(frameIterator *proto.ForwardFrameIterator, keyDecoder, valueDecoder Decoder) []proto.Pair { if CodecUtil.NextFrameIsNullFrame(frameIterator) { return nil } - return EntryListCodec.Decode(frameIterator, keyDecoder, valueDecoder) + return DecodeEntryList(frameIterator, keyDecoder, valueDecoder) } -func (entryListCodec) DecodeForStringAndEntryListIntegerLong(frameIterator *proto.ForwardFrameIterator) []proto.Pair { +func DecodeEntryListForStringAndEntryListIntegerLong(frameIterator *proto.ForwardFrameIterator) []proto.Pair { result := make([]proto.Pair, 0) frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { key := DecodeString(frameIterator) - value := EntryListIntegerLongCodec.Decode(frameIterator) + value := DecodeEntryListIntegerLong(frameIterator) result = append(result, proto.NewPair(key, value)) } frameIterator.Next() return result } -func (entryListCodec) DecodeForDataAndData(frameIterator *proto.ForwardFrameIterator) []proto.Pair { +func DecodeEntryListForDataAndData(frameIterator *proto.ForwardFrameIterator) []proto.Pair { result := make([]proto.Pair, 0) frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { - key := DataCodec.Decode(frameIterator) - value := DataCodec.Decode(frameIterator) + key := DecodeData(frameIterator) + value := DecodeData(frameIterator) result = append(result, proto.NewPair(key, value)) } frameIterator.Next() return result } -//EntryListIntegerIntegerCodec -type entryListIntegerIntegerCodec struct{} - -var EntryListIntegerIntegerCodec entryListIntegerIntegerCodec - -func (entryListIntegerIntegerCodec) EncodeListInteger(message *proto.ClientMessage, entries []proto.Pair) { +func EncodeListIntegerIntegerInteger(message *proto.ClientMessage, entries []proto.Pair) { entryCount := len(entries) frame := proto.NewFrame(make([]byte, entryCount*proto.EntrySizeInBytes)) for i := 0; i < entryCount; i++ { @@ -284,7 +264,7 @@ func (entryListIntegerIntegerCodec) EncodeListInteger(message *proto.ClientMessa message.AddFrame(frame) } -func (entryListIntegerIntegerCodec) Decode(frameIterator *proto.ForwardFrameIterator) []proto.Pair { +func DecodeListIntegerIntegerInteger(frameIterator *proto.ForwardFrameIterator) []proto.Pair { frame := frameIterator.Next() itemCount := len(frame.Content) / proto.EntrySizeInBytes result := make([]proto.Pair, itemCount) @@ -296,12 +276,7 @@ func (entryListIntegerIntegerCodec) Decode(frameIterator *proto.ForwardFrameIter return result } -// EntryListUUIDLongCodec -type entryListUUIDLongCodec struct{} - -var EntryListUUIDLongCodec entryListUUIDLongCodec - -func (entryListUUIDLongCodec) Encode(message *proto.ClientMessage, entries []proto.Pair) { +func EncodeEntryListUUIDLong(message *proto.ClientMessage, entries []proto.Pair) { size := len(entries) content := make([]byte, size*proto.EntrySizeInBytes) newFrame := proto.NewFrame(content) @@ -314,7 +289,20 @@ func (entryListUUIDLongCodec) Encode(message *proto.ClientMessage, entries []pro message.AddFrame(newFrame) } -func (entryListUUIDLongCodec) Decode(frameIterator *proto.ForwardFrameIterator) []proto.Pair { +func EncodeEntryListIntegerInteger(message *proto.ClientMessage, entries []proto.Pair) { + size := len(entries) + content := make([]byte, size*proto.EntrySizeInBytes) + newFrame := proto.NewFrame(content) + for i, entry := range entries { + key := entry.Key().(int32) + value := entry.Value().(int32) + FixSizedTypesCodec.EncodeInt(content, int32(i*proto.EntrySizeInBytes), key) + FixSizedTypesCodec.EncodeInt(content, int32(i*proto.EntrySizeInBytes+proto.UUIDSizeInBytes), value) + } + message.AddFrame(newFrame) +} + +func DecodeEntryListUUIDLong(frameIterator *proto.ForwardFrameIterator) []proto.Pair { nextFrame := frameIterator.Next() itemCount := len(nextFrame.Content) / proto.EntrySizeInBytes content := make([]proto.Pair, itemCount) @@ -326,12 +314,19 @@ func (entryListUUIDLongCodec) Decode(frameIterator *proto.ForwardFrameIterator) return content } -// EntryListUUIDListIntegerCodec -type entryListUUIDListIntegerCodec struct{} - -var EntryListUUIDListIntegerCodec entryListUUIDListIntegerCodec +func DecodeEntryListIntegerInteger(frameIterator *proto.ForwardFrameIterator) []proto.Pair { + nextFrame := frameIterator.Next() + itemCount := len(nextFrame.Content) / proto.EntrySizeInBytes + content := make([]proto.Pair, itemCount) + for i := 0; i < itemCount; i++ { + key := FixSizedTypesCodec.DecodeInt(nextFrame.Content, int32(i*proto.EntrySizeInBytes)) + value := FixSizedTypesCodec.DecodeInt(nextFrame.Content, int32(i*proto.EntrySizeInBytes+proto.IntSizeInBytes)) + content[i] = proto.NewPair(key, value) + } + return content +} -func (entryListUUIDListIntegerCodec) Encode(message *proto.ClientMessage, entries []proto.Pair) { +func EncodeEntryListUUIDListInteger(message *proto.ClientMessage, entries []proto.Pair) { entryCount := len(entries) uuids := make([]core.UUID, entryCount) message.AddFrame(proto.BeginFrame) @@ -343,12 +338,12 @@ func (entryListUUIDListIntegerCodec) Encode(message *proto.ClientMessage, entrie EncodeListInteger(message, value) } message.AddFrame(proto.EndFrame) - ListUUIDCodec.Encode(message, uuids) + EncodeListUUID(message, uuids) } -func (entryListUUIDListIntegerCodec) Decode(frameIterator *proto.ForwardFrameIterator) []proto.Pair { - values := ListMultiFrameCodec.DecodeWithListInteger(frameIterator) - keys := ListUUIDCodec.Decode(frameIterator) +func DecodeEntryListUUIDListInteger(frameIterator *proto.ForwardFrameIterator) []proto.Pair { + values := DecodeListMultiFrameWithListInteger(frameIterator) + keys := DecodeListUUID(frameIterator) keySize := len(keys) result := make([]proto.Pair, keySize) for i := 0; i < keySize; i++ { @@ -357,11 +352,7 @@ func (entryListUUIDListIntegerCodec) Decode(frameIterator *proto.ForwardFrameIte return result } -type entryListIntegerUUIDCodec struct{} - -var EntryListIntegerUUIDCodec entryListIntegerUUIDCodec - -func (entryListIntegerUUIDCodec) Decode(frameIterator *proto.ForwardFrameIterator) []proto.Pair { +func DecodeEntryListIntegerUUID(frameIterator *proto.ForwardFrameIterator) []proto.Pair { frame := frameIterator.Next() entryCount := len(frame.Content) / proto.EntrySizeInBytes result := make([]proto.Pair, entryCount) @@ -373,12 +364,7 @@ func (entryListIntegerUUIDCodec) Decode(frameIterator *proto.ForwardFrameIterato return result } -// entryListIntegerUUIDCodec -type entryListIntegerLongCodec struct{} - -var EntryListIntegerLongCodec entryListIntegerLongCodec - -func (entryListIntegerLongCodec) Decode(iterator *proto.ForwardFrameIterator) []proto.Pair { +func DecodeEntryListIntegerLong(iterator *proto.ForwardFrameIterator) []proto.Pair { frame := iterator.Next() entryCount := len(frame.Content) / proto.EntrySizeInBytes result := make([]proto.Pair, entryCount) @@ -476,12 +462,7 @@ func DecodeListInteger(frameIterator *proto.ForwardFrameIterator) []int32 { return result } -// ListLongCodec -type listLongCodec struct{} - -var ListLongCodec listLongCodec - -func (listLongCodec) Encode(message *proto.ClientMessage, entries []int64) { +func EncodeListLong(message *proto.ClientMessage, entries []int64) { itemCount := len(entries) frame := proto.NewFrame(make([]byte, itemCount*proto.LongSizeInBytes)) for i := 0; i < itemCount; i++ { @@ -490,7 +471,7 @@ func (listLongCodec) Encode(message *proto.ClientMessage, entries []int64) { message.AddFrame(frame) } -func (listLongCodec) Decode(frameIterator *proto.ForwardFrameIterator) []int64 { +func DecodeListLong(frameIterator *proto.ForwardFrameIterator) []int64 { frame := frameIterator.Next() itemCount := len(frame.Content) / proto.LongSizeInBytes result := make([]int64, itemCount) @@ -500,12 +481,7 @@ func (listLongCodec) Decode(frameIterator *proto.ForwardFrameIterator) []int64 { return result } -//ListMultiFrameCodec -type listMultiFrameCodec struct{} - -var ListMultiFrameCodec listMultiFrameCodec - -func (listMultiFrameCodec) Encode(message *proto.ClientMessage, values []serialization.Data, encoder Encoder) { +func EncodeListMultiFrame(message *proto.ClientMessage, values []serialization.Data, encoder Encoder) { message.AddFrame(proto.BeginFrame) for i := 0; i < len(values); i++ { encoder(message, values[i]) @@ -513,15 +489,15 @@ func (listMultiFrameCodec) Encode(message *proto.ClientMessage, values []seriali message.AddFrame(proto.EndFrame) } -func (listMultiFrameCodec) EncodeForData(message *proto.ClientMessage, values []serialization.Data) { +func EncodeListMultiFrameForData(message *proto.ClientMessage, values []serialization.Data) { message.AddFrame(proto.BeginFrame) for i := 0; i < len(values); i++ { - DataCodec.Encode(message, values[i]) + EncodeData(message, values[i]) } message.AddFrame(proto.EndFrame) } -func (c listMultiFrameCodec) EncodeForString(message *proto.ClientMessage, values []string) { +func EncodeListMultiFrameForString(message *proto.ClientMessage, values []string) { message.AddFrame(proto.BeginFrame) for i := 0; i < len(values); i++ { EncodeString(message, values[i]) @@ -529,7 +505,7 @@ func (c listMultiFrameCodec) EncodeForString(message *proto.ClientMessage, value message.AddFrame(proto.EndFrame) } -func (c listMultiFrameCodec) EncodeForStackTraceElement(message *proto.ClientMessage, values []proto.StackTraceElement) { +func EncodeListMultiFrameForStackTraceElement(message *proto.ClientMessage, values []proto.StackTraceElement) { message.AddFrame(proto.BeginFrame) for i := 0; i < len(values); i++ { EncodeStackTraceElement(message, values[i]) @@ -537,7 +513,7 @@ func (c listMultiFrameCodec) EncodeForStackTraceElement(message *proto.ClientMes message.AddFrame(proto.EndFrame) } -func (listMultiFrameCodec) EncodeContainsNullable(message *proto.ClientMessage, values []serialization.Data, encoder Encoder) { +func EncodeListMultiFrameContainsNullable(message *proto.ClientMessage, values []serialization.Data, encoder Encoder) { message.AddFrame(proto.BeginFrame) for i := 0; i < len(values); i++ { if values[i] == nil { @@ -549,25 +525,25 @@ func (listMultiFrameCodec) EncodeContainsNullable(message *proto.ClientMessage, message.AddFrame(proto.EndFrame) } -func (listMultiFrameCodec) EncodeNullable(message *proto.ClientMessage, values []serialization.Data, encoder Encoder) { +func EncodeListMultiFrameNullable(message *proto.ClientMessage, values []serialization.Data, encoder Encoder) { if len(values) == 0 { message.AddFrame(proto.NullFrame) } else { - ListMultiFrameCodec.Encode(message, values, encoder) + EncodeListMultiFrame(message, values, encoder) } } -func (listMultiFrameCodec) DecodeForData(frameIterator *proto.ForwardFrameIterator) []serialization.Data { +func DecodeListMultiFrameForData(frameIterator *proto.ForwardFrameIterator) []serialization.Data { result := make([]serialization.Data, 0) frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { - result = append(result, DataCodec.Decode(frameIterator)) + result = append(result, DecodeData(frameIterator)) } frameIterator.Next() return result } -func (c listMultiFrameCodec) DecodeWithListInteger(frameIterator *proto.ForwardFrameIterator) []int32 { +func DecodeListMultiFrameWithListInteger(frameIterator *proto.ForwardFrameIterator) []int32 { result := make([]int32, 0) frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { @@ -577,7 +553,7 @@ func (c listMultiFrameCodec) DecodeWithListInteger(frameIterator *proto.ForwardF return result } -func (c listMultiFrameCodec) DecodeForDistributedObjectInfo(frameIterator *proto.ForwardFrameIterator) []proto.DistributedObjectInfo { +func DecodeListMultiFrameForDistributedObjectInfo(frameIterator *proto.ForwardFrameIterator) []proto.DistributedObjectInfo { result := make([]proto.DistributedObjectInfo, 0) frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { @@ -587,7 +563,7 @@ func (c listMultiFrameCodec) DecodeForDistributedObjectInfo(frameIterator *proto return result } -func (c listMultiFrameCodec) DecodeForMemberInfo(frameIterator *proto.ForwardFrameIterator) []proto.MemberInfo { +func DecodeListMultiFrameForMemberInfo(frameIterator *proto.ForwardFrameIterator) []proto.MemberInfo { result := make([]proto.MemberInfo, 0) frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { @@ -597,7 +573,7 @@ func (c listMultiFrameCodec) DecodeForMemberInfo(frameIterator *proto.ForwardFra return result } -func (listMultiFrameCodec) DecodeForStackTraceElement(frameIterator *proto.ForwardFrameIterator) []proto.StackTraceElement { +func DecodeListMultiFrameForStackTraceElement(frameIterator *proto.ForwardFrameIterator) []proto.StackTraceElement { result := make([]proto.StackTraceElement, 0) frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { @@ -607,7 +583,7 @@ func (listMultiFrameCodec) DecodeForStackTraceElement(frameIterator *proto.Forwa return result } -func (listMultiFrameCodec) DecodeForString(frameIterator *proto.ForwardFrameIterator) []string { +func DecodeListMultiFrameForString(frameIterator *proto.ForwardFrameIterator) []string { result := make([]string, 0) frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { @@ -617,39 +593,29 @@ func (listMultiFrameCodec) DecodeForString(frameIterator *proto.ForwardFrameIter return result } -func (listMultiFrameCodec) DecodeForDataContainsNullable(frameIterator *proto.ForwardFrameIterator) []serialization.Data { +func DecodeListMultiFrameForDataContainsNullable(frameIterator *proto.ForwardFrameIterator) []serialization.Data { result := make([]serialization.Data, 0) frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { if CodecUtil.NextFrameIsNullFrame(frameIterator) { result = append(result, nil) } else { - result = append(result, DataCodec.Decode(frameIterator)) + result = append(result, DecodeData(frameIterator)) } } frameIterator.Next() return result } -// listDataCodec -type listDataCodec struct{} - -var ListDataCodec listDataCodec - -func (listDataCodec) Encode(message *proto.ClientMessage, entries []serialization.Data) { - ListMultiFrameCodec.EncodeForData(message, entries) +func EncodeListData(message *proto.ClientMessage, entries []serialization.Data) { + EncodeListMultiFrameForData(message, entries) } -func (listDataCodec) Decode(frameIterator *proto.ForwardFrameIterator) []serialization.Data { - return ListMultiFrameCodec.DecodeForData(frameIterator) +func DecodeListData(frameIterator *proto.ForwardFrameIterator) []serialization.Data { + return DecodeListMultiFrameForData(frameIterator) } -// listUUIDCodec -type listUUIDCodec struct{} - -var ListUUIDCodec listUUIDCodec - -func (listUUIDCodec) Encode(message *proto.ClientMessage, entries []core.UUID) { +func EncodeListUUID(message *proto.ClientMessage, entries []core.UUID) { itemCount := len(entries) content := make([]byte, itemCount*proto.UUIDSizeInBytes) newFrame := proto.NewFrame(content) @@ -659,7 +625,7 @@ func (listUUIDCodec) Encode(message *proto.ClientMessage, entries []core.UUID) { message.AddFrame(newFrame) } -func (listUUIDCodec) Decode(frameIterator *proto.ForwardFrameIterator) []core.UUID { +func DecodeListUUID(frameIterator *proto.ForwardFrameIterator) []core.UUID { frame := frameIterator.Next() itemCount := len(frame.Content) / proto.UUIDSizeInBytes result := make([]core.UUID, itemCount) @@ -669,12 +635,7 @@ func (listUUIDCodec) Decode(frameIterator *proto.ForwardFrameIterator) []core.UU return result } -// LongArrayCodec -type longArrayCodec struct{} - -var LongArrayCodec longArrayCodec - -func (longArrayCodec) Encode(message *proto.ClientMessage, entries []int64) { +func EncodeLongArray(message *proto.ClientMessage, entries []int64) { itemCount := len(entries) frame := proto.NewFrame(make([]byte, itemCount*proto.LongSizeInBytes)) for i := 0; i < itemCount; i++ { @@ -683,7 +644,7 @@ func (longArrayCodec) Encode(message *proto.ClientMessage, entries []int64) { message.AddFrame(frame) } -func (longArrayCodec) Decode(frameIterator *proto.ForwardFrameIterator) []int64 { +func DecodeLongArray(frameIterator *proto.ForwardFrameIterator) []int64 { frame := frameIterator.Next() itemCount := len(frame.Content) / proto.LongSizeInBytes result := make([]int64, itemCount) @@ -693,12 +654,7 @@ func (longArrayCodec) Decode(frameIterator *proto.ForwardFrameIterator) []int64 return result } -// MapCodec -type mapCodec struct{} - -var MapCodec mapCodec - -func (mapCodec) EncodeForStringAndString(message *proto.ClientMessage, values map[string]string) { +func EncodeMapForStringAndString(message *proto.ClientMessage, values map[string]string) { message.AddFrame(proto.BeginFrame.Copy()) for key, value := range values { EncodeString(message, key) @@ -707,7 +663,7 @@ func (mapCodec) EncodeForStringAndString(message *proto.ClientMessage, values ma message.AddFrame(proto.EndFrame.Copy()) } -func (mapCodec) EncodeForEndpointQualifierAndAddress(message *proto.ClientMessage, values map[proto.EndpointQualifier]proto.Address) { +func EncodeMapForEndpointQualifierAndAddress(message *proto.ClientMessage, values map[proto.EndpointQualifier]proto.Address) { message.AddFrame(proto.BeginFrame.Copy()) for key, value := range values { EncodeEndpointQualifier(message, key) @@ -716,9 +672,8 @@ func (mapCodec) EncodeForEndpointQualifierAndAddress(message *proto.ClientMessag message.AddFrame(proto.EndFrame.Copy()) } -func (c mapCodec) DecodeForStringAndString(iterator *proto.ForwardFrameIterator) map[string]string { +func DecodeMapForStringAndString(iterator *proto.ForwardFrameIterator) map[string]string { result := map[string]string{} - iterator.Next() for !iterator.PeekNext().IsEndFrame() { key := DecodeString(iterator) @@ -726,13 +681,11 @@ func (c mapCodec) DecodeForStringAndString(iterator *proto.ForwardFrameIterator) result[key] = value } iterator.Next() - return result } -func (c mapCodec) DecodeForEndpointQualifierAndAddress(iterator *proto.ForwardFrameIterator) interface{} { +func DecodeMapForEndpointQualifierAndAddress(iterator *proto.ForwardFrameIterator) interface{} { result := map[proto.EndpointQualifier]proto.Address{} - iterator.Next() for !iterator.PeekNext().IsEndFrame() { key := DecodeEndpointQualifier(iterator) @@ -740,7 +693,6 @@ func (c mapCodec) DecodeForEndpointQualifierAndAddress(iterator *proto.ForwardFr result[key] = value } iterator.Next() - return result } From ae8f640bc4ad2b65bb0295a3b1a564814dcdf404 Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Thu, 25 Feb 2021 06:11:06 +0300 Subject: [PATCH 14/41] More Go generator updates --- go/__init__.py | 4 ++-- go/codec-template.go.j2 | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index a3ad0ebcf..32c9db97e 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -67,7 +67,7 @@ def import_statement(self): class PathHolders: - Address = ImportPathHolder("Address", "/core") + Address = ImportPathHolder("Address", "") AddressCodec = ImportPathHolder("AddressCodec", "", is_custom_codec=True) AnchorDataListHolder = ImportPathHolder("AnchorDataListHolder", "") AnchorDataListHolderCodec = ImportPathHolder("AnchorDataListHolderCodec", "", is_custom_codec=True) @@ -104,7 +104,7 @@ class PathHolders: MemberInfoCodec = ImportPathHolder("MemberInfoCodec", "", is_custom_codec=True) MemberVersion = ImportPathHolder("MemberVersion", "/core") MemberVersionCodec = ImportPathHolder("MemberVersionCodec", "", is_custom_codec=True) - PagingPredicateHolder = ImportPathHolder("PagingPredicateHolder", "/core") + PagingPredicateHolder = ImportPathHolder("PagingPredicateHolder", "") PagingPredicateHolderCodec = ImportPathHolder("PagingPredicateHolderCodec", "", is_custom_codec=True) RaftGroupId = ImportPathHolder("RaftGroupId", "") RaftGroupIdCodec = ImportPathHolder("RaftGroupIdCodec", "", is_custom_codec=True) diff --git a/go/codec-template.go.j2 b/go/codec-template.go.j2 index 90f18bb81..2fcbe5ff4 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.go.j2 @@ -157,7 +157,7 @@ func Decode{{ service_name|capital }}{{ method.name|capital }}Response(clientMes {% endfor %} } {% else %} -func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(clientMessage *proto.ClientMessage) ({% for param in method.response.params %}{{ escape_keyword(param.name)}} {{ lang_types_encode(param.type) }}{{ ", " if not loop.last }}{% endfor %}{% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists: boolean;{% endfor %}) { +func Decode{{ service_name|capital }}{{ method.name|capital }}Response(clientMessage *proto.ClientMessage) ({% for param in method.response.params %}{{ escape_keyword(param.name)}} {{ lang_types_encode(param.type) }}{{ ", " if not loop.last }}{% endfor %}{% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists: boolean;{% endfor %}) { {% if response_fix_sized_params|length != 0 %} frameIterator := clientMessage.FrameIterator() initialFrame := frameIterator.Next() @@ -197,7 +197,7 @@ func ({{ service_name|lower }}{{ method.name|capital }}Codec) DecodeResponse(cli {# EVENTS#} {% if method.events|length != 0 %} -func ({{ service_name|lower }}{{ method.name|capital }}Codec) Handle(clientMessage *proto.ClientMessage, {% for event in method.events%}handle{{ event.name|capital }}Event func({% for param in event.params %}{% if param in new_event_params %}is{{ param.name|capital }}Exists, {% endif %}{{param.name}} {{ lang_types_encode(param.type) }}{% if not loop.last %}, {% endif %}{% endfor %}){% if not loop.last %}, {% endif %}{% endfor %}){ +func Handle{{ service_name|capital }}{{ method.name|capital }}(clientMessage *proto.ClientMessage, {% for event in method.events%}handle{{ event.name|capital }}Event func({% for param in event.params %}{% if param in new_event_params %}is{{ param.name|capital }}Exists, {% endif %}{{param.name}} {{ lang_types_encode(param.type) }}{% if not loop.last %}, {% endif %}{% endfor %}){% if not loop.last %}, {% endif %}{% endfor %}){ messageType := clientMessage.GetMessageType() frameIterator := clientMessage.FrameIterator() {% for event in method.events%} From 537081b00233654a0934ec453cdd64ee333f9573 Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Thu, 25 Feb 2021 11:15:55 +0300 Subject: [PATCH 15/41] More Go generator updates --- go/__init__.py | 4 ++-- go/verbatim/builtin.go | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index 32c9db97e..7936c6a39 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -162,7 +162,7 @@ class PathHolders: } _go_types_common = { - "Address": "proto.Address", + "Address": "*proto.Address", "AttributeConfig": "NA", "BitmapIndexOptions": "config.BitmapIndexOptions", "CacheConfigHolder": "NA", @@ -183,7 +183,7 @@ class PathHolders: "ListenerConfigHolder": "NA", "Long": "int64", "MapStoreConfigHolder": "NA", - "Map_EndpointQualifier_Address": "map[proto.EndpointQualifier]proto.Address", + "Map_EndpointQualifier_Address": "map[proto.EndpointQualifier]*proto.Address", "Map_String_String": "map[string]string", "MemberInfo": "proto.MemberInfo", "MergePolicyConfig": "NA", diff --git a/go/verbatim/builtin.go b/go/verbatim/builtin.go index 53792f28a..1b3883dfc 100644 --- a/go/verbatim/builtin.go +++ b/go/verbatim/builtin.go @@ -57,7 +57,7 @@ func (codecUtil) EncodeNullableForBitmapIndexOptions(message *proto.ClientMessag if options == nil { message.AddFrame(proto.NullFrame.Copy()) } else { - EncodeBitmapIndexOptions(message, options) + EncodeBitmapIndexOptions(message, *options) } } @@ -81,7 +81,7 @@ func (codecUtil) DecodeNullableForAddress(frameIterator *proto.ForwardFrameItera return nil } addr := DecodeAddress(frameIterator) - return &addr + return addr } func (codecUtil) DecodeNullableForLongArray(frameIterator *proto.ForwardFrameIterator) []int64 { @@ -663,7 +663,7 @@ func EncodeMapForStringAndString(message *proto.ClientMessage, values map[string message.AddFrame(proto.EndFrame.Copy()) } -func EncodeMapForEndpointQualifierAndAddress(message *proto.ClientMessage, values map[proto.EndpointQualifier]proto.Address) { +func EncodeMapForEndpointQualifierAndAddress(message *proto.ClientMessage, values map[proto.EndpointQualifier]*proto.Address) { message.AddFrame(proto.BeginFrame.Copy()) for key, value := range values { EncodeEndpointQualifier(message, key) @@ -685,7 +685,7 @@ func DecodeMapForStringAndString(iterator *proto.ForwardFrameIterator) map[strin } func DecodeMapForEndpointQualifierAndAddress(iterator *proto.ForwardFrameIterator) interface{} { - result := map[proto.EndpointQualifier]proto.Address{} + result := map[proto.EndpointQualifier]*proto.Address{} iterator.Next() for !iterator.PeekNext().IsEndFrame() { key := DecodeEndpointQualifier(iterator) From afed8974f4769ae6e1357dc3336f10a0225d0943 Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Thu, 25 Feb 2021 15:36:55 +0300 Subject: [PATCH 16/41] More Go generator updates --- go/__init__.py | 4 ++-- go/verbatim/builtin.go | 12 +++++------- 2 files changed, 7 insertions(+), 9 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index 7936c6a39..de39649d9 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -162,7 +162,7 @@ class PathHolders: } _go_types_common = { - "Address": "*proto.Address", + "Address": "*core.Address", "AttributeConfig": "NA", "BitmapIndexOptions": "config.BitmapIndexOptions", "CacheConfigHolder": "NA", @@ -183,7 +183,7 @@ class PathHolders: "ListenerConfigHolder": "NA", "Long": "int64", "MapStoreConfigHolder": "NA", - "Map_EndpointQualifier_Address": "map[proto.EndpointQualifier]*proto.Address", + "Map_EndpointQualifier_Address": "map[proto.EndpointQualifier]*core.Address", "Map_String_String": "map[string]string", "MemberInfo": "proto.MemberInfo", "MergePolicyConfig": "NA", diff --git a/go/verbatim/builtin.go b/go/verbatim/builtin.go index 1b3883dfc..c5b4e2c20 100644 --- a/go/verbatim/builtin.go +++ b/go/verbatim/builtin.go @@ -4,13 +4,11 @@ import ( "encoding/binary" "strings" + "github.com/hazelcast/hazelcast-go-client/v4/internal/config" "github.com/hazelcast/hazelcast-go-client/v4/internal/core" "github.com/hazelcast/hazelcast-go-client/v4/internal/proto" - "github.com/hazelcast/hazelcast-go-client/v4/internal/serialization/spi" - "github.com/hazelcast/hazelcast-go-client/v4/internal/serialization" - - "github.com/hazelcast/hazelcast-go-client/v4/internal/config" + "github.com/hazelcast/hazelcast-go-client/v4/internal/serialization/spi" ) // Encoder for ClientMessage and value @@ -76,7 +74,7 @@ func (codecUtil) DecodeNullableForData(frameIterator *proto.ForwardFrameIterator return DecodeData(frameIterator) } -func (codecUtil) DecodeNullableForAddress(frameIterator *proto.ForwardFrameIterator) *proto.Address { +func (codecUtil) DecodeNullableForAddress(frameIterator *proto.ForwardFrameIterator) *core.Address { if CodecUtil.NextFrameIsNullFrame(frameIterator) { return nil } @@ -663,7 +661,7 @@ func EncodeMapForStringAndString(message *proto.ClientMessage, values map[string message.AddFrame(proto.EndFrame.Copy()) } -func EncodeMapForEndpointQualifierAndAddress(message *proto.ClientMessage, values map[proto.EndpointQualifier]*proto.Address) { +func EncodeMapForEndpointQualifierAndAddress(message *proto.ClientMessage, values map[proto.EndpointQualifier]*core.Address) { message.AddFrame(proto.BeginFrame.Copy()) for key, value := range values { EncodeEndpointQualifier(message, key) @@ -685,7 +683,7 @@ func DecodeMapForStringAndString(iterator *proto.ForwardFrameIterator) map[strin } func DecodeMapForEndpointQualifierAndAddress(iterator *proto.ForwardFrameIterator) interface{} { - result := map[proto.EndpointQualifier]*proto.Address{} + result := map[proto.EndpointQualifier]*core.Address{} iterator.Next() for !iterator.PeekNext().IsEndFrame() { key := DecodeEndpointQualifier(iterator) From 99e52018306d139005e88440c4f478ac8ba78e13 Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Wed, 10 Mar 2021 14:40:26 +0300 Subject: [PATCH 17/41] - Fix initialFrame in Go templates - Verbatim file copying required Python 3.8+, re-written for Python < 3.8 --- go/codec-template.go.j2 | 10 +++++++--- go/verbatim/builtin.go | 4 ++-- util.py | 15 ++++++++------- 3 files changed, 17 insertions(+), 12 deletions(-) diff --git a/go/codec-template.go.j2 b/go/codec-template.go.j2 index 2fcbe5ff4..4fb015373 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.go.j2 @@ -7,9 +7,13 @@ Encode{% if param.nullable %}Nullable{% endif %}Map(clientMessage, {{ param_name(param.name) }}, Encode{{ key_type(lang_name, param.type) }}, Encode{{ value_type(lang_name, param.type) }}{% if loop_last %}, True{% endif %}) {%- else -%} {%- if param.nullable -%} - CodecUtil.EncodeNullable(clientMessage, {{ param_name(param.name) }}, Encode{{ lang_name(param.type) }}{% if loop_last %}, True{% endif %}) + {%- if param.type|lower == "string" -%} + CodecUtil.EncodeNullableForString(clientMessage, {{ param_name(param.name) }}) + {%- else -%} + CodecUtil.EncodeNullable(clientMessage, {{ param_name(param.name) }}, Encode{{ lang_name(param.type) }}{% if loop_last %}, True{% endif %}) + {%- endif -%} {%- else -%} - Encode{{ lang_name(param.type) }}(clientMessage, {{ param_name(param.name) }}{% if loop_last %}, True{% endif %}) + Encode{{ lang_name(param.type) }}(clientMessage, {{ param_name(param.name) }}{% if loop_last %}, True{% endif %}) {%- endif %} {% endif %} {%- endmacro %} @@ -121,7 +125,7 @@ func Encode{{ service_name|capital }}{{ method.name|capital }}Request({% for par clientMessage := proto.NewClientMessageForEncode() clientMessage.SetRetryable({{ method.request.retryable|lower }}) - initialFrame := proto.NewFrame(make([]byte, {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize)) + initialFrame := proto.NewFrameWith(make([]byte, {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize), proto.UnfragmentedMessage) {% for param in request_fix_sized_params %} FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset, {{ escape_keyword(param.name) }}) {% endfor %} diff --git a/go/verbatim/builtin.go b/go/verbatim/builtin.go index c5b4e2c20..748c0caa8 100644 --- a/go/verbatim/builtin.go +++ b/go/verbatim/builtin.go @@ -422,8 +422,8 @@ func (fixSizedTypesCodec) EncodeUUID(buffer []byte, offset int32, uuid core.UUID return } bufferOffset := offset + proto.BooleanSizeInBytes - FixSizedTypesCodec.EncodeLong(buffer, bufferOffset, int64(uuid.GetMostSignificantBits())) - FixSizedTypesCodec.EncodeLong(buffer, bufferOffset+proto.LongSizeInBytes, int64(uuid.GetLeastSignificantBits())) + FixSizedTypesCodec.EncodeLong(buffer, bufferOffset, int64(uuid.MostSignificantBits())) + FixSizedTypesCodec.EncodeLong(buffer, bufferOffset+proto.LongSizeInBytes, int64(uuid.LeastSignificantBits())) } func (fixSizedTypesCodec) DecodeUUID(buffer []byte, offset int32) core.UUID { diff --git a/util.py b/util.py index c629ae832..1681c0562 100644 --- a/util.py +++ b/util.py @@ -1,11 +1,11 @@ import hashlib import json import os -import shutil import re from os import listdir, makedirs from os.path import dirname, isfile, join, realpath from enum import Enum +from distutils.dir_util import copy_tree import jsonschema import yaml @@ -437,12 +437,13 @@ def copy_verbatim_files(output_dir, lang, env): # iterate the verbatim directory and copy files to output # creating directories if necessary print("Verbatim files found, copying from %s to %s" % (verbatim_dir, output_dir)) - shutil.copytree( - verbatim_dir, - output_dir, - ignore=shutil.ignore_patterns(".*"), - dirs_exist_ok=True - ) + copy_tree(verbatim_dir, output_dir) + # shutil.copytree( + # verbatim_dir, + # output_dir, + # ignore=shutil.ignore_patterns(".*"), + # dirs_exist_ok=True + # ) class SupportedLanguages(Enum): From 00c427a81f23190f07869535da7898dc94883b22 Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Tue, 16 Mar 2021 10:12:01 +0300 Subject: [PATCH 18/41] Updated Go generator --- go/__init__.py | 405 +++++++++++++++++---------------- go/custom-codec-template.go.j2 | 1 + go/verbatim/builtin.go | 52 ++--- 3 files changed, 237 insertions(+), 221 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index de39649d9..1dc1ba897 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -20,7 +20,10 @@ def go_types_encode(key): try: go_type = _go_types_encode[key] except KeyError: - go_type = _go_types_common[key] + try: + go_type = _go_types_common[key] + except KeyError: + go_type = "NA" if go_type == "NA": raise NotImplementedError("Missing type mapping for '" + key + "'") return go_type @@ -30,16 +33,15 @@ def go_types_decode(key): try: go_type = _go_types_decode[key] except KeyError: - go_type = _go_types_common[key] + try: + go_type = _go_types_common[key] + except KeyError: + go_type = "NA" if go_type == "NA": raise NotImplementedError("Missing type for '" + key + "'") return go_type -def go_get_import_path_holders(param_type): - return import_paths.get(param_type, []) - - def go_get_import_statements(*args): import_statements = set() for arg in args: @@ -47,8 +49,11 @@ def go_get_import_statements(*args): for param in params: type = param["type"] if isinstance(param, dict) else param for path_holder in import_paths.get(type, []): - if path_holder.path: - import_statements.add(path_holder.import_statement) + if path_holder.name.endswith("Codec"): + continue + path = path_holder.import_statement + if path is not None: + import_statements.add(path) return import_statements @@ -56,64 +61,74 @@ class ImportPathHolder: def __init__(self, name, path, is_builtin_codec=False, is_custom_codec=False): self.name = name self.path = path - self.is_builtin_codec = is_builtin_codec - self.is_custom_codec = is_custom_codec @property def import_statement(self): if not self.path: return "" + return '''"github.com/hazelcast/hazelcast-go-client/v%s/hazelcast%s"''' % (CLIENT_VERSION, self.path) + + +class InternalImportPathHolder: + def __init__(self, name, path, is_builtin_codec=False, is_custom_codec=False): + self.name = name + self.path = path + + @property + def import_statement(self): + if self.path is None: + return "" return '''"github.com/hazelcast/hazelcast-go-client/v%s/internal%s"''' % (CLIENT_VERSION, self.path) class PathHolders: - Address = ImportPathHolder("Address", "") - AddressCodec = ImportPathHolder("AddressCodec", "", is_custom_codec=True) - AnchorDataListHolder = ImportPathHolder("AnchorDataListHolder", "") - AnchorDataListHolderCodec = ImportPathHolder("AnchorDataListHolderCodec", "", is_custom_codec=True) - BitmapIndexOptions = ImportPathHolder("BitmapIndexOptions", "/config") - BitmapIndexOptionsCodec = ImportPathHolder("BitmapIndexOptionsCodec", "", is_custom_codec=True) - ByteArrayCodec = ImportPathHolder("ByteArrayCodec", "", is_builtin_codec=True) - CodecUtilCodec = ImportPathHolder("CodecUtil", "", is_builtin_codec=True) - Data = ImportPathHolder('Data', '/serialization') - DataCodec = ImportPathHolder("DataCodec", "", is_builtin_codec=True) - DistributedObjectInfo = ImportPathHolder("DistributedObjectInfo", "/core") - DistributedObjectInfoCodec = ImportPathHolder("DistributedObjectInfoCodec", "", is_custom_codec=True) - # EndpointQualifier = ImportPathHolder("EndpointQualifier", "/protocol") - EndpointQualifierCodec = ImportPathHolder("EndpointQualifierCodec", "", is_custom_codec=True) - EntryListCodec = ImportPathHolder("EntryListCodec", "", is_builtin_codec=True) - EntryListIntegerIntegerCodec = ImportPathHolder("EntryListIntegerIntegerCodec", "", is_builtin_codec=True) - EntryListIntegerLongCodec = ImportPathHolder("EntryListIntegerLongCodec", "", is_builtin_codec=True) - EntryListIntegerUUIDCodec = ImportPathHolder("EntryListIntegerUUIDCodec", "", is_builtin_codec=True) - EntryListLongByteArrayCodec = ImportPathHolder("EntryListLongByteArrayCodec", "", is_builtin_codec=True) - EntryListUUIDListIntegerCodec = ImportPathHolder("EntryListUUIDListIntegerCodec", "", is_builtin_codec=True) - EntryListUUIDLongCodec = ImportPathHolder("EntryListUUIDLongCodec", "", is_builtin_codec=True) - EntryListUUIDUUIDCodec = ImportPathHolder("EntryListUUIDUUIDCodec", "", is_builtin_codec=True) - ErrorHolder = ImportPathHolder("ErrorHolder", "") - ErrorHolderCodec = ImportPathHolder("ErrorHolderCodec", "", is_custom_codec=True) - IndexConfig = ImportPathHolder("IndexConfig", "/core") - IndexConfigCodec = ImportPathHolder("IndexConfigCodec", "", is_custom_codec=True) - ListDataCodec = ImportPathHolder("ListDataCodec", "", is_builtin_codec=True) - ListIntegerCodec = ImportPathHolder("ListIntegerCodec", "", is_builtin_codec=True) - ListLongCodec = ImportPathHolder("ListLongCodec", "", is_builtin_codec=True) - ListMultiFrameCodec = ImportPathHolder("ListMultiFrameCodec", "", is_builtin_codec=True) - ListUUIDCodec = ImportPathHolder("ListUUIDCodec", "", is_builtin_codec=True) - LongArrayCodec = ImportPathHolder("LongArrayCodec", "", is_builtin_codec=True) - MapCodec = ImportPathHolder("MapCodec", "", is_builtin_codec=True) - MemberInfo = ImportPathHolder("MemberInfo", "/core") - MemberInfoCodec = ImportPathHolder("MemberInfoCodec", "", is_custom_codec=True) - MemberVersion = ImportPathHolder("MemberVersion", "/core") - MemberVersionCodec = ImportPathHolder("MemberVersionCodec", "", is_custom_codec=True) - PagingPredicateHolder = ImportPathHolder("PagingPredicateHolder", "") - PagingPredicateHolderCodec = ImportPathHolder("PagingPredicateHolderCodec", "", is_custom_codec=True) - RaftGroupId = ImportPathHolder("RaftGroupId", "") - RaftGroupIdCodec = ImportPathHolder("RaftGroupIdCodec", "", is_custom_codec=True) - SimpleEntryView = ImportPathHolder("SimpleEntryView", "/core") - SimpleEntryViewCodec = ImportPathHolder("SimpleEntryViewCodec", "", is_custom_codec=True) - StackTraceElement = ImportPathHolder("StackTraceElement", "") - StackTraceElementCodec = ImportPathHolder("StackTraceElementCodec", "", is_custom_codec=True) - StringCodec = ImportPathHolder("StringCodec", "", is_builtin_codec=True) - UUID = ImportPathHolder('UUID', '/core') + Address = ImportPathHolder("Address", "/cluster") + AddressCodec = InternalImportPathHolder("AddressCodec", None, is_custom_codec=True) + AnchorDataListHolder = InternalImportPathHolder("AnchorDataListHolder", "") + AnchorDataListHolderCodec = InternalImportPathHolder("AnchorDataListHolderCodec", "", is_custom_codec=True) + BitmapIndexOptions = InternalImportPathHolder("BitmapIndexOptions", "") + BitmapIndexOptionsCodec = InternalImportPathHolder("BitmapIndexOptionsCodec", None, is_custom_codec=True) + ByteArrayCodec = InternalImportPathHolder("ByteArrayCodec", "", is_builtin_codec=True) + CodecUtilCodec = InternalImportPathHolder("CodecUtil", "", is_builtin_codec=True) + Data = InternalImportPathHolder('Data', '/serialization') + DataCodec = InternalImportPathHolder("DataCodec", "", is_builtin_codec=True) + DistributedObjectInfo = InternalImportPathHolder("DistributedObjectInfo", "") + DistributedObjectInfoCodec = InternalImportPathHolder("DistributedObjectInfoCodec", None, is_custom_codec=True) + EndpointQualifier = InternalImportPathHolder("EndpointQualifier", "") + EndpointQualifierCodec = InternalImportPathHolder("EndpointQualifierCodec", None, is_custom_codec=True) + EntryListCodec = InternalImportPathHolder("EntryListCodec", "", is_builtin_codec=True) + EntryListIntegerIntegerCodec = InternalImportPathHolder("EntryListIntegerIntegerCodec", "", is_builtin_codec=True) + EntryListIntegerLongCodec = InternalImportPathHolder("EntryListIntegerLongCodec", "", is_builtin_codec=True) + EntryListIntegerUUIDCodec = InternalImportPathHolder("EntryListIntegerUUIDCodec", "", is_builtin_codec=True) + EntryListLongByteArrayCodec = InternalImportPathHolder("EntryListLongByteArrayCodec", "", is_builtin_codec=True) + EntryListUUIDListIntegerCodec = InternalImportPathHolder("EntryListUUIDListIntegerCodec", "", is_builtin_codec=True) + EntryListUUIDLongCodec = InternalImportPathHolder("EntryListUUIDLongCodec", "", is_builtin_codec=True) + EntryListUUIDUUIDCodec = InternalImportPathHolder("EntryListUUIDUUIDCodec", "", is_builtin_codec=True) + ErrorHolder = InternalImportPathHolder("ErrorHolder", "") + ErrorHolderCodec = InternalImportPathHolder("ErrorHolderCodec", "", is_custom_codec=True) + IndexConfig = InternalImportPathHolder("IndexConfig", "/core") + IndexConfigCodec = InternalImportPathHolder("IndexConfigCodec", "", is_custom_codec=True) + ListDataCodec = InternalImportPathHolder("ListDataCodec", "", is_builtin_codec=True) + ListIntegerCodec = InternalImportPathHolder("ListIntegerCodec", "", is_builtin_codec=True) + ListLongCodec = InternalImportPathHolder("ListLongCodec", "", is_builtin_codec=True) + ListMultiFrameCodec = InternalImportPathHolder("ListMultiFrameCodec", None, is_builtin_codec=True) + ListUUIDCodec = InternalImportPathHolder("ListUUIDCodec", "", is_builtin_codec=True) + LongArrayCodec = InternalImportPathHolder("LongArrayCodec", "", is_builtin_codec=True) + MapCodec = InternalImportPathHolder("MapCodec", None, is_builtin_codec=True) + MemberInfo = ImportPathHolder("MemberInfo", "/cluster") + MemberInfoCodec = InternalImportPathHolder("MemberInfoCodec", "", is_custom_codec=True) + MemberVersion = ImportPathHolder("MemberVersion", "/cluster") + MemberVersionCodec = InternalImportPathHolder("MemberVersionCodec", None, is_custom_codec=True) + PagingPredicateHolder = InternalImportPathHolder("PagingPredicateHolder", "") + PagingPredicateHolderCodec = InternalImportPathHolder("PagingPredicateHolderCodec", "", is_custom_codec=True) + RaftGroupId = InternalImportPathHolder("RaftGroupId", "") + RaftGroupIdCodec = InternalImportPathHolder("RaftGroupIdCodec", "", is_custom_codec=True) + SimpleEntryView = InternalImportPathHolder("SimpleEntryView", "") + SimpleEntryViewCodec = InternalImportPathHolder("SimpleEntryViewCodec", None, is_custom_codec=True) + StackTraceElement = ImportPathHolder("StackTraceElement", "/hzerror") + StackTraceElementCodec = InternalImportPathHolder("StackTraceElementCodec", None, is_custom_codec=True) + StringCodec = InternalImportPathHolder("StringCodec", None, is_builtin_codec=True) + UUID = InternalImportPathHolder("UUID", "") import_paths = { @@ -162,157 +177,157 @@ class PathHolders: } _go_types_common = { - "Address": "*core.Address", - "AttributeConfig": "NA", - "BitmapIndexOptions": "config.BitmapIndexOptions", - "CacheConfigHolder": "NA", - "CacheEventData": "NA", - "CacheSimpleEntryListenerConfig": "NA", - "ClientBwListEntry": "NA", + "Address": "cluster.Address", + # "AttributeConfig": "NA", + "BitmapIndexOptions": "internal.BitmapIndexOptions", + # "CacheConfigHolder": "NA", + # "CacheEventData": "NA", + # "CacheSimpleEntryListenerConfig": "NA", + # "ClientBwListEntry": "NA", "Data": "serialization.Data", - "DistributedObjectInfo": "proto.DistributedObjectInfo", - "DurationConfig": "NA", - "EndpointQualifier": "proto.EndpointQualifier", - "ErrorHolder": "proto.ErrorHolder", - "EventJournalConfig": "NA", - "EvictionConfigHolder": "NA", - "HotRestartConfig": "NA", - "IndexConfig": "config.IndexConfig", - "Integer": "int32", - "List_CPMember": "NA", - "ListenerConfigHolder": "NA", - "Long": "int64", - "MapStoreConfigHolder": "NA", - "Map_EndpointQualifier_Address": "map[proto.EndpointQualifier]*core.Address", + "DistributedObjectInfo": "internal.DistributedObjectInfo", + # "DurationConfig": "NA", + "EndpointQualifier": "internal.EndpointQualifier", + # "ErrorHolder": "proto.ErrorHolder", + # "EventJournalConfig": "NA", + # "EvictionConfigHolder": "NA", + # "HotRestartConfig": "NA", + # "IndexConfig": "config.IndexConfig", + # "Integer": "int32", + # "List_CPMember": "NA", + # "ListenerConfigHolder": "NA", + # "Long": "int64", + # "MapStoreConfigHolder": "NA", + "Map_EndpointQualifier_Address": "map[internal.EndpointQualifier]cluster.Address", "Map_String_String": "map[string]string", - "MemberInfo": "proto.MemberInfo", - "MergePolicyConfig": "NA", - "MerkleTreeConfig": "NA", - "NearCacheConfigHolder": "NA", - "NearCachePreloaderConfig": "NA", - "Pair": "serialization.Pair", - "PredicateConfigHolder": "NA", - "QueryCacheConfigHolder": "NA", - "QueueStoreConfigHolder": "NA", - "RaftGroupId": "proto.RaftGroupId", - "RingbufferStoreConfigHolder": "NA", - "SimpleEntryView": "*core.SimpleEntryView", - "StackTraceElement": "proto.StackTraceElement", + # "MemberInfo": "proto.MemberInfo", + # "MergePolicyConfig": "NA", + # "MerkleTreeConfig": "NA", + # "NearCacheConfigHolder": "NA", + # "NearCachePreloaderConfig": "NA", + # "Pair": "serialization.Pair", + # "PredicateConfigHolder": "NA", + # "QueryCacheConfigHolder": "NA", + # "QueueStoreConfigHolder": "NA", + # "RaftGroupId": "proto.RaftGroupId", + # "RingbufferStoreConfigHolder": "NA", + "SimpleEntryView": "*internal.SimpleEntryView", + "StackTraceElement": "hzerror.StackTraceElement", "String": "string", - "TimedExpiryPolicyFactoryConfig": "NA", - "UUID": "core.UUID", - "WanReplicationRef": "NA", + # "TimedExpiryPolicyFactoryConfig": "NA", + "UUID": "internal.UUID", + # "WanReplicationRef": "NA", "boolean": "bool", "byte": "byte", - "byteArray": "[]byte", + # "byteArray": "[]byte", "int": "int32", "long": "int64", - "longArray": "[]int64", + # "longArray": "[]int64", } _go_types_encode = { - "AnchorDataListHolder": "proto.AnchorDataListHolder", - "CPMember": "NA", - "CacheEventData": "NA", - "ClientBwListEntry": "NA", - "EntryList_Data_Data": "[]proto.Pair", - "EntryList_Data_List_Data": "[]proto.Pair", - "EntryList_Integer_Integer": "[]proto.Pair", - "EntryList_Integer_Long": "[]proto.Pair", - "EntryList_Integer_UUID": "[]proto.Pair", - "EntryList_Long_byteArray": "[]proto.Pair", - "EntryList_String_EntryList_Integer_Long": "[]proto.Pair", - "EntryList_String_String": "[]proto.Pair", - "EntryList_String_byteArray": "[]proto.Pair", - "EntryList_UUID_List_Integer": "[]proto.Pair", - "EntryList_UUID_Long": "[]proto.Pair", - "EntryList_UUID_UUID": "[]proto.Pair", - "ListCN_Data": "[]serialization.Data", - "List_AttributeConfig": "NA", - "List_CacheEventData": "NA", - "List_CacheSimpleEntryListenerConfig": "NA", - "List_ClientBwListEntry": "NA", - "List_Data": "[]serialization.Data", - "List_DistributedObjectInfo": "[]DistributedObjectInfo", - "List_IndexConfig": "[]IndexConfig", - "List_Integer": "[]int32", - "List_ListCN_Data": "NA", - "List_List_Data": "[]serialization.Data", - "List_ListenerConfigHolder": "NA", - "List_Long": "[]int64", - "List_MCEvent": "NA", - "List_MemberInfo": "[]proto.MemberInfo", - "List_QueryCacheConfigHolder": "NA", - "List_QueryCacheEventData": "NA", - "List_ScheduledTaskHandler": "NA", - "List_SqlColumnMetadata": "NA", - "List_StackTraceElement": "[]proto.StackTraceElement", + # "AnchorDataListHolder": "proto.AnchorDataListHolder", + # "CPMember": "NA", + # "CacheEventData": "NA", + # "ClientBwListEntry": "NA", + # "EntryList_Data_Data": "[]proto.Pair", + # "EntryList_Data_List_Data": "[]proto.Pair", + # "EntryList_Integer_Integer": "[]proto.Pair", + # "EntryList_Integer_Long": "[]proto.Pair", + # "EntryList_Integer_UUID": "[]proto.Pair", + # "EntryList_Long_byteArray": "[]proto.Pair", + # "EntryList_String_EntryList_Integer_Long": "[]proto.Pair", + # "EntryList_String_String": "[]proto.Pair", + # "EntryList_String_byteArray": "[]proto.Pair", + # "EntryList_UUID_List_Integer": "[]proto.Pair", + # "EntryList_UUID_Long": "[]proto.Pair", + # "EntryList_UUID_UUID": "[]proto.Pair", + # "ListCN_Data": "[]serialization.Data", + # "List_AttributeConfig": "NA", + # "List_CacheEventData": "NA", + # "List_CacheSimpleEntryListenerConfig": "NA", + # "List_ClientBwListEntry": "NA", + # "List_Data": "[]serialization.Data", + # "List_DistributedObjectInfo": "[]DistributedObjectInfo", + # "List_IndexConfig": "[]IndexConfig", + # "List_Integer": "[]int32", + # "List_ListCN_Data": "NA", + # "List_List_Data": "[]serialization.Data", + # "List_ListenerConfigHolder": "NA", + # "List_Long": "[]int64", + # "List_MCEvent": "NA", + # "List_MemberInfo": "[]proto.MemberInfo", + # "List_QueryCacheConfigHolder": "NA", + # "List_QueryCacheEventData": "NA", + # "List_ScheduledTaskHandler": "NA", + # "List_SqlColumnMetadata": "NA", + # "List_StackTraceElement": "[]proto.StackTraceElement", "List_String": "[]string", - "List_UUID": "[]core.UUID", - "List_Xid": "NA", - "MCEvent": "NA", - "MemberInfo": "proto.MemberInfo", - "MemberVersion": "proto.MemberVersion", - "MigrationState": "NA", - "PagingPredicateHolder": "proto.PagingPredicateHolder", - "QueryCacheEventData": "NA", - "ScheduledTaskHandler": "NA", - "SqlColumnMetadata": "NA", - "SqlError": "NA", - "SqlQueryId": "NA", - "Xid": "NA", + # "List_UUID": "[]core.UUID", + # "List_Xid": "NA", + # "MCEvent": "NA", + "MemberInfo": "cluster.MemberInfo", + "MemberVersion": "cluster.MemberVersion", + # "MigrationState": "NA", + # "PagingPredicateHolder": "proto.PagingPredicateHolder", + # "QueryCacheEventData": "NA", + # "ScheduledTaskHandler": "NA", + # "SqlColumnMetadata": "NA", + # "SqlError": "NA", + # "SqlQueryId": "NA", + # "Xid": "NA", } _go_types_decode = { - "AnchorDataListHolder": "proto.AnchorDataListHolder", - "CPMember": "NA", - "CacheEventData": "NA", - "ClientBwListEntry": "NA", - "EntryList_Data_Data": "[]proto.Pair", - "EntryList_Data_List_Data": "[]proto.Pair", - "EntryList_Integer_Integer": "[]proto.Pair", - "EntryList_Integer_Long": "[]proto.Pair", - "EntryList_Integer_UUID": "[]proto.Pair", - "EntryList_Long_byteArray": "[]proto.Pair", - "EntryList_String_EntryList_Integer_Long": "[]proto.Pair", - "EntryList_String_String": "[]proto.Pair", - "EntryList_String_byteArray": "[]proto.Pair", - "EntryList_UUID_List_Integer": "[]proto.Pair", - "EntryList_UUID_Long": "[]proto.Pair", - "EntryList_UUID_UUID": "[]proto.Pair", - "ListCN_Data": "[]serialization.Data", - "List_AttributeConfig": "NA", - "List_CPMember": "NA", - "List_CacheEventData": "NA", - "List_CacheSimpleEntryListenerConfig": "NA", - "List_ClientBwListEntry": "NA", - "List_Data": "[]serialization.Data", - "List_DistributedObjectInfo": "[]proto.DistributedObjectInfo", - "List_IndexConfig": "[]IndexConfig", - "List_Integer": "[]int32", - "List_ListCN_Data": "NA", - "List_List_Data": "[]serialization.Data", - "List_ListenerConfigHolder": "NA", - "List_Long": "[]int64", - "List_MCEvent": "NA", - "List_MemberInfo": "[]proto.MemberInfo", - "List_QueryCacheConfigHolder": "NA", - "List_QueryCacheEventData": "NA", - "List_ScheduledTaskHandler": "NA", - "List_SqlColumnMetadata": "NA", - "List_StackTraceElement": "[]proto.StackTraceElement", + # "AnchorDataListHolder": "proto.AnchorDataListHolder", + # "CPMember": "NA", + # "CacheEventData": "NA", + # "ClientBwListEntry": "NA", + # "EntryList_Data_Data": "[]proto.Pair", + # "EntryList_Data_List_Data": "[]proto.Pair", + # "EntryList_Integer_Integer": "[]proto.Pair", + # "EntryList_Integer_Long": "[]proto.Pair", + # "EntryList_Integer_UUID": "[]proto.Pair", + # "EntryList_Long_byteArray": "[]proto.Pair", + # "EntryList_String_EntryList_Integer_Long": "[]proto.Pair", + # "EntryList_String_String": "[]proto.Pair", + # "EntryList_String_byteArray": "[]proto.Pair", + # "EntryList_UUID_List_Integer": "[]proto.Pair", + # "EntryList_UUID_Long": "[]proto.Pair", + # "EntryList_UUID_UUID": "[]proto.Pair", + # "ListCN_Data": "[]serialization.Data", + # "List_AttributeConfig": "NA", + # "List_CPMember": "NA", + # "List_CacheEventData": "NA", + # "List_CacheSimpleEntryListenerConfig": "NA", + # "List_ClientBwListEntry": "NA", + # "List_Data": "[]serialization.Data", + # "List_DistributedObjectInfo": "[]proto.DistributedObjectInfo", + # "List_IndexConfig": "[]IndexConfig", + # "List_Integer": "[]int32", + # "List_ListCN_Data": "NA", + # "List_List_Data": "[]serialization.Data", + # "List_ListenerConfigHolder": "NA", + # "List_Long": "[]int64", + # "List_MCEvent": "NA", + # "List_MemberInfo": "[]proto.MemberInfo", + # "List_QueryCacheConfigHolder": "NA", + # "List_QueryCacheEventData": "NA", + # "List_ScheduledTaskHandler": "NA", + # "List_SqlColumnMetadata": "NA", + # "List_StackTraceElement": "[]proto.StackTraceElement", "List_String": "[]string", - "List_UUID": "[]core.UUID", - "List_Xid": "NA", - "MCEvent": "NA", - "MemberInfo": "proto.MemberInfo", - "MemberVersion": "proto.MemberVersion", - "MigrationState": "NA", - "PagingPredicateHolder": "proto.PagingPredicateHolder", - "QueryCacheEventData": "NA", - "ScheduledTaskHandler": "NA", - "SqlColumnMetadata": "NA", - "SqlError": "NA", - "SqlQueryId": "NA", - "Xid": "NA", + # "List_UUID": "[]core.UUID", + # "List_Xid": "NA", + # "MCEvent": "NA", + "MemberInfo": "cluster.MemberInfo", + "MemberVersion": "cluster.MemberVersion", + # "MigrationState": "NA", + # "PagingPredicateHolder": "proto.PagingPredicateHolder", + # "QueryCacheEventData": "NA", + # "ScheduledTaskHandler": "NA", + # "SqlColumnMetadata": "NA", + # "SqlError": "NA", + # "SqlQueryId": "NA", + # "Xid": "NA", } diff --git a/go/custom-codec-template.go.j2 b/go/custom-codec-template.go.j2 index 4ff15ac31..fdb568b3c 100644 --- a/go/custom-codec-template.go.j2 +++ b/go/custom-codec-template.go.j2 @@ -60,6 +60,7 @@ package codec {{ insert_import_statements( get_import_path_holders( + codec.name, fix_sized_params, var_sized_params ) diff --git a/go/verbatim/builtin.go b/go/verbatim/builtin.go index 748c0caa8..922df5f01 100644 --- a/go/verbatim/builtin.go +++ b/go/verbatim/builtin.go @@ -2,10 +2,11 @@ package codec import ( "encoding/binary" + "github.com/hazelcast/hazelcast-go-client/v4/hazelcast/hzerror" "strings" - "github.com/hazelcast/hazelcast-go-client/v4/internal/config" - "github.com/hazelcast/hazelcast-go-client/v4/internal/core" + pubcluster "github.com/hazelcast/hazelcast-go-client/v4/hazelcast/cluster" + "github.com/hazelcast/hazelcast-go-client/v4/internal" "github.com/hazelcast/hazelcast-go-client/v4/internal/proto" "github.com/hazelcast/hazelcast-go-client/v4/internal/serialization" "github.com/hazelcast/hazelcast-go-client/v4/internal/serialization/spi" @@ -51,11 +52,11 @@ func (codecUtil) EncodeNullableForString(message *proto.ClientMessage, value str } } -func (codecUtil) EncodeNullableForBitmapIndexOptions(message *proto.ClientMessage, options *config.BitmapIndexOptions) { +func (codecUtil) EncodeNullableForBitmapIndexOptions(message *proto.ClientMessage, options internal.BitmapIndexOptions) { if options == nil { message.AddFrame(proto.NullFrame.Copy()) } else { - EncodeBitmapIndexOptions(message, *options) + EncodeBitmapIndexOptions(message, options) } } @@ -74,12 +75,11 @@ func (codecUtil) DecodeNullableForData(frameIterator *proto.ForwardFrameIterator return DecodeData(frameIterator) } -func (codecUtil) DecodeNullableForAddress(frameIterator *proto.ForwardFrameIterator) *core.Address { +func (codecUtil) DecodeNullableForAddress(frameIterator *proto.ForwardFrameIterator) pubcluster.Address { if CodecUtil.NextFrameIsNullFrame(frameIterator) { return nil } - addr := DecodeAddress(frameIterator) - return addr + return DecodeAddress(frameIterator) } func (codecUtil) DecodeNullableForLongArray(frameIterator *proto.ForwardFrameIterator) []int64 { @@ -108,7 +108,7 @@ func (codecUtil) NextFrameIsNullFrame(frameIterator *proto.ForwardFrameIterator) return isNullFrame } -func (codecUtil) DecodeNullableForBitmapIndexOptions(frameIterator *proto.ForwardFrameIterator) *config.BitmapIndexOptions { +func (codecUtil) DecodeNullableForBitmapIndexOptions(frameIterator *proto.ForwardFrameIterator) internal.BitmapIndexOptions { isNullFrame := frameIterator.PeekNext().IsNullFrame() if isNullFrame { frameIterator.Next() @@ -116,7 +116,7 @@ func (codecUtil) DecodeNullableForBitmapIndexOptions(frameIterator *proto.Forwar return DecodeBitmapIndexOptions(frameIterator) } -func (codecUtil) DecodeNullableForSimpleEntryView(frameIterator *proto.ForwardFrameIterator) *core.SimpleEntryView { +func (codecUtil) DecodeNullableForSimpleEntryView(frameIterator *proto.ForwardFrameIterator) *internal.SimpleEntryView { isNullFrame := frameIterator.PeekNext().IsNullFrame() if isNullFrame { frameIterator.Next() @@ -279,7 +279,7 @@ func EncodeEntryListUUIDLong(message *proto.ClientMessage, entries []proto.Pair) content := make([]byte, size*proto.EntrySizeInBytes) newFrame := proto.NewFrame(content) for i, entry := range entries { - key := entry.Key().(core.UUID) + key := entry.Key().(internal.UUID) value := entry.Value().(int64) FixSizedTypesCodec.EncodeUUID(content, int32(i*proto.EntrySizeInBytes), key) FixSizedTypesCodec.EncodeLong(content, int32(i*proto.EntrySizeInBytes+proto.UUIDSizeInBytes), value) @@ -326,11 +326,11 @@ func DecodeEntryListIntegerInteger(frameIterator *proto.ForwardFrameIterator) [] func EncodeEntryListUUIDListInteger(message *proto.ClientMessage, entries []proto.Pair) { entryCount := len(entries) - uuids := make([]core.UUID, entryCount) + uuids := make([]internal.UUID, entryCount) message.AddFrame(proto.BeginFrame) for i := 0; i < entryCount; i++ { entry := entries[i] - key := entry.Key().(core.UUID) + key := entry.Key().(internal.UUID) value := entry.Value().([]int32) uuids[i] = key EncodeListInteger(message, value) @@ -415,7 +415,7 @@ func (fixSizedTypesCodec) DecodeByte(buffer []byte, offset int32) byte { return buffer[offset] } -func (fixSizedTypesCodec) EncodeUUID(buffer []byte, offset int32, uuid core.UUID) { +func (fixSizedTypesCodec) EncodeUUID(buffer []byte, offset int32, uuid internal.UUID) { isNullEncode := uuid == nil FixSizedTypesCodec.EncodeBoolean(buffer, offset, isNullEncode) if isNullEncode { @@ -426,7 +426,7 @@ func (fixSizedTypesCodec) EncodeUUID(buffer []byte, offset int32, uuid core.UUID FixSizedTypesCodec.EncodeLong(buffer, bufferOffset+proto.LongSizeInBytes, int64(uuid.LeastSignificantBits())) } -func (fixSizedTypesCodec) DecodeUUID(buffer []byte, offset int32) core.UUID { +func (fixSizedTypesCodec) DecodeUUID(buffer []byte, offset int32) internal.UUID { isNull := FixSizedTypesCodec.DecodeBoolean(buffer, offset) if isNull { return nil @@ -437,7 +437,7 @@ func (fixSizedTypesCodec) DecodeUUID(buffer []byte, offset int32) core.UUID { mostSignificant := uint64(FixSizedTypesCodec.DecodeLong(buffer, mostSignificantOffset)) leastSignificant := uint64(FixSizedTypesCodec.DecodeLong(buffer, leastSignificantOffset)) - return core.NewUUIDWith(mostSignificant, leastSignificant) + return internal.NewUUIDWith(mostSignificant, leastSignificant) } func EncodeListInteger(message *proto.ClientMessage, entries []int32) { @@ -551,8 +551,8 @@ func DecodeListMultiFrameWithListInteger(frameIterator *proto.ForwardFrameIterat return result } -func DecodeListMultiFrameForDistributedObjectInfo(frameIterator *proto.ForwardFrameIterator) []proto.DistributedObjectInfo { - result := make([]proto.DistributedObjectInfo, 0) +func DecodeListMultiFrameForDistributedObjectInfo(frameIterator *proto.ForwardFrameIterator) []internal.DistributedObjectInfo { + result := make([]internal.DistributedObjectInfo, 0) frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { result = append(result, DecodeDistributedObjectInfo(frameIterator)) @@ -561,8 +561,8 @@ func DecodeListMultiFrameForDistributedObjectInfo(frameIterator *proto.ForwardFr return result } -func DecodeListMultiFrameForMemberInfo(frameIterator *proto.ForwardFrameIterator) []proto.MemberInfo { - result := make([]proto.MemberInfo, 0) +func DecodeListMultiFrameForMemberInfo(frameIterator *proto.ForwardFrameIterator) []pubcluster.MemberInfo { + result := make([]pubcluster.MemberInfo, 0) frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { result = append(result, DecodeMemberInfo(frameIterator)) @@ -571,8 +571,8 @@ func DecodeListMultiFrameForMemberInfo(frameIterator *proto.ForwardFrameIterator return result } -func DecodeListMultiFrameForStackTraceElement(frameIterator *proto.ForwardFrameIterator) []proto.StackTraceElement { - result := make([]proto.StackTraceElement, 0) +func DecodeListMultiFrameForStackTraceElement(frameIterator *proto.ForwardFrameIterator) []hzerror.StackTraceElement { + result := make([]hzerror.StackTraceElement, 0) frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { result = append(result, DecodeStackTraceElement(frameIterator)) @@ -613,7 +613,7 @@ func DecodeListData(frameIterator *proto.ForwardFrameIterator) []serialization.D return DecodeListMultiFrameForData(frameIterator) } -func EncodeListUUID(message *proto.ClientMessage, entries []core.UUID) { +func EncodeListUUID(message *proto.ClientMessage, entries []internal.UUID) { itemCount := len(entries) content := make([]byte, itemCount*proto.UUIDSizeInBytes) newFrame := proto.NewFrame(content) @@ -623,10 +623,10 @@ func EncodeListUUID(message *proto.ClientMessage, entries []core.UUID) { message.AddFrame(newFrame) } -func DecodeListUUID(frameIterator *proto.ForwardFrameIterator) []core.UUID { +func DecodeListUUID(frameIterator *proto.ForwardFrameIterator) []internal.UUID { frame := frameIterator.Next() itemCount := len(frame.Content) / proto.UUIDSizeInBytes - result := make([]core.UUID, itemCount) + result := make([]internal.UUID, itemCount) for i := 0; i < itemCount; i++ { result[i] = FixSizedTypesCodec.DecodeUUID(frame.Content, int32(i*proto.UUIDSizeInBytes)) } @@ -661,7 +661,7 @@ func EncodeMapForStringAndString(message *proto.ClientMessage, values map[string message.AddFrame(proto.EndFrame.Copy()) } -func EncodeMapForEndpointQualifierAndAddress(message *proto.ClientMessage, values map[proto.EndpointQualifier]*core.Address) { +func EncodeMapForEndpointQualifierAndAddress(message *proto.ClientMessage, values map[internal.EndpointQualifier]pubcluster.Address) { message.AddFrame(proto.BeginFrame.Copy()) for key, value := range values { EncodeEndpointQualifier(message, key) @@ -683,7 +683,7 @@ func DecodeMapForStringAndString(iterator *proto.ForwardFrameIterator) map[strin } func DecodeMapForEndpointQualifierAndAddress(iterator *proto.ForwardFrameIterator) interface{} { - result := map[proto.EndpointQualifier]*core.Address{} + result := map[internal.EndpointQualifier]pubcluster.Address{} iterator.Next() for !iterator.PeekNext().IsEndFrame() { key := DecodeEndpointQualifier(iterator) From 1e7288125cc3f0aeb3397e5a8711f99b4c301bca Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Sat, 20 Mar 2021 04:20:30 +0300 Subject: [PATCH 19/41] Enabled more codecs --- go/__init__.py | 90 ++++++++++++++++++++--------------------- go/codec-template.go.j2 | 2 +- 2 files changed, 46 insertions(+), 46 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index 1dc1ba897..702752605 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -193,19 +193,19 @@ class PathHolders: # "EvictionConfigHolder": "NA", # "HotRestartConfig": "NA", # "IndexConfig": "config.IndexConfig", - # "Integer": "int32", + "Integer": "int32", # "List_CPMember": "NA", # "ListenerConfigHolder": "NA", - # "Long": "int64", + "Long": "int64", # "MapStoreConfigHolder": "NA", "Map_EndpointQualifier_Address": "map[internal.EndpointQualifier]cluster.Address", "Map_String_String": "map[string]string", - # "MemberInfo": "proto.MemberInfo", + "MemberInfo": "cluster.MemberInfo", # "MergePolicyConfig": "NA", # "MerkleTreeConfig": "NA", # "NearCacheConfigHolder": "NA", # "NearCachePreloaderConfig": "NA", - # "Pair": "serialization.Pair", + "Pair": "proto.Pair", # "PredicateConfigHolder": "NA", # "QueryCacheConfigHolder": "NA", # "QueueStoreConfigHolder": "NA", @@ -219,10 +219,10 @@ class PathHolders: # "WanReplicationRef": "NA", "boolean": "bool", "byte": "byte", - # "byteArray": "[]byte", + "byteArray": "[]byte", "int": "int32", "long": "int64", - # "longArray": "[]int64", + "longArray": "[]int64", } _go_types_encode = { @@ -230,40 +230,40 @@ class PathHolders: # "CPMember": "NA", # "CacheEventData": "NA", # "ClientBwListEntry": "NA", - # "EntryList_Data_Data": "[]proto.Pair", - # "EntryList_Data_List_Data": "[]proto.Pair", - # "EntryList_Integer_Integer": "[]proto.Pair", - # "EntryList_Integer_Long": "[]proto.Pair", - # "EntryList_Integer_UUID": "[]proto.Pair", - # "EntryList_Long_byteArray": "[]proto.Pair", - # "EntryList_String_EntryList_Integer_Long": "[]proto.Pair", - # "EntryList_String_String": "[]proto.Pair", - # "EntryList_String_byteArray": "[]proto.Pair", - # "EntryList_UUID_List_Integer": "[]proto.Pair", - # "EntryList_UUID_Long": "[]proto.Pair", - # "EntryList_UUID_UUID": "[]proto.Pair", + "EntryList_Data_Data": "[]proto.Pair", + "EntryList_Data_List_Data": "[]proto.Pair", + "EntryList_Integer_Integer": "[]proto.Pair", + "EntryList_Integer_Long": "[]proto.Pair", + "EntryList_Integer_UUID": "[]proto.Pair", + "EntryList_Long_byteArray": "[]proto.Pair", + "EntryList_String_EntryList_Integer_Long": "[]proto.Pair", + "EntryList_String_String": "[]proto.Pair", + "EntryList_String_byteArray": "[]proto.Pair", + "EntryList_UUID_List_Integer": "[]proto.Pair", + "EntryList_UUID_Long": "[]proto.Pair", + "EntryList_UUID_UUID": "[]proto.Pair", # "ListCN_Data": "[]serialization.Data", # "List_AttributeConfig": "NA", # "List_CacheEventData": "NA", # "List_CacheSimpleEntryListenerConfig": "NA", # "List_ClientBwListEntry": "NA", - # "List_Data": "[]serialization.Data", - # "List_DistributedObjectInfo": "[]DistributedObjectInfo", + "List_Data": "[]serialization.Data", + "List_DistributedObjectInfo": "[]internal.DistributedObjectInfo", # "List_IndexConfig": "[]IndexConfig", - # "List_Integer": "[]int32", + "List_Integer": "[]int32", # "List_ListCN_Data": "NA", - # "List_List_Data": "[]serialization.Data", + "List_List_Data": "[]serialization.Data", # "List_ListenerConfigHolder": "NA", - # "List_Long": "[]int64", + "List_Long": "[]int64", # "List_MCEvent": "NA", - # "List_MemberInfo": "[]proto.MemberInfo", + "List_MemberInfo": "[]cluster.MemberInfo", # "List_QueryCacheConfigHolder": "NA", # "List_QueryCacheEventData": "NA", # "List_ScheduledTaskHandler": "NA", # "List_SqlColumnMetadata": "NA", - # "List_StackTraceElement": "[]proto.StackTraceElement", + "List_StackTraceElement": "[]hzerror.StackTraceElement", "List_String": "[]string", - # "List_UUID": "[]core.UUID", + "List_UUID": "[]internal.UUID", # "List_Xid": "NA", # "MCEvent": "NA", "MemberInfo": "cluster.MemberInfo", @@ -283,41 +283,41 @@ class PathHolders: # "CPMember": "NA", # "CacheEventData": "NA", # "ClientBwListEntry": "NA", - # "EntryList_Data_Data": "[]proto.Pair", - # "EntryList_Data_List_Data": "[]proto.Pair", - # "EntryList_Integer_Integer": "[]proto.Pair", - # "EntryList_Integer_Long": "[]proto.Pair", - # "EntryList_Integer_UUID": "[]proto.Pair", - # "EntryList_Long_byteArray": "[]proto.Pair", - # "EntryList_String_EntryList_Integer_Long": "[]proto.Pair", - # "EntryList_String_String": "[]proto.Pair", - # "EntryList_String_byteArray": "[]proto.Pair", - # "EntryList_UUID_List_Integer": "[]proto.Pair", - # "EntryList_UUID_Long": "[]proto.Pair", - # "EntryList_UUID_UUID": "[]proto.Pair", + "EntryList_Data_Data": "[]proto.Pair", + "EntryList_Data_List_Data": "[]proto.Pair", + "EntryList_Integer_Integer": "[]proto.Pair", + "EntryList_Integer_Long": "[]proto.Pair", + "EntryList_Integer_UUID": "[]proto.Pair", + "EntryList_Long_byteArray": "[]proto.Pair", + "EntryList_String_EntryList_Integer_Long": "[]proto.Pair", + "EntryList_String_String": "[]proto.Pair", + "EntryList_String_byteArray": "[]proto.Pair", + "EntryList_UUID_List_Integer": "[]proto.Pair", + "EntryList_UUID_Long": "[]proto.Pair", + "EntryList_UUID_UUID": "[]proto.Pair", # "ListCN_Data": "[]serialization.Data", # "List_AttributeConfig": "NA", # "List_CPMember": "NA", # "List_CacheEventData": "NA", # "List_CacheSimpleEntryListenerConfig": "NA", # "List_ClientBwListEntry": "NA", - # "List_Data": "[]serialization.Data", - # "List_DistributedObjectInfo": "[]proto.DistributedObjectInfo", + "List_Data": "[]serialization.Data", + "List_DistributedObjectInfo": "[]internal.DistributedObjectInfo", # "List_IndexConfig": "[]IndexConfig", - # "List_Integer": "[]int32", + "List_Integer": "[]int32", # "List_ListCN_Data": "NA", - # "List_List_Data": "[]serialization.Data", + "List_List_Data": "[]serialization.Data", # "List_ListenerConfigHolder": "NA", - # "List_Long": "[]int64", + "List_Long": "[]int64", # "List_MCEvent": "NA", - # "List_MemberInfo": "[]proto.MemberInfo", + "List_MemberInfo": "[]cluster.MemberInfo", # "List_QueryCacheConfigHolder": "NA", # "List_QueryCacheEventData": "NA", # "List_ScheduledTaskHandler": "NA", # "List_SqlColumnMetadata": "NA", # "List_StackTraceElement": "[]proto.StackTraceElement", "List_String": "[]string", - # "List_UUID": "[]core.UUID", + "List_UUID": "[]internal.UUID", # "List_Xid": "NA", # "MCEvent": "NA", "MemberInfo": "cluster.MemberInfo", diff --git a/go/codec-template.go.j2 b/go/codec-template.go.j2 index 4fb015373..1e82c2743 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.go.j2 @@ -202,7 +202,7 @@ func Decode{{ service_name|capital }}{{ method.name|capital }}Response(clientMes {% if method.events|length != 0 %} func Handle{{ service_name|capital }}{{ method.name|capital }}(clientMessage *proto.ClientMessage, {% for event in method.events%}handle{{ event.name|capital }}Event func({% for param in event.params %}{% if param in new_event_params %}is{{ param.name|capital }}Exists, {% endif %}{{param.name}} {{ lang_types_encode(param.type) }}{% if not loop.last %}, {% endif %}{% endfor %}){% if not loop.last %}, {% endif %}{% endfor %}){ - messageType := clientMessage.GetMessageType() + messageType := clientMessage.Type() frameIterator := clientMessage.FrameIterator() {% for event in method.events%} if messageType == {{ service_name|capital }}{{ method.name|capital }}CodecEvent{{ event.name|capital }}MessageType { From 1aa3e12c71a9e3f4b2b30e6e853bd1557380a6a9 Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Fri, 26 Mar 2021 18:27:09 +0300 Subject: [PATCH 20/41] Enabled more codecs --- go/__init__.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index 702752605..510a8dd51 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -106,7 +106,7 @@ class PathHolders: EntryListUUIDUUIDCodec = InternalImportPathHolder("EntryListUUIDUUIDCodec", "", is_builtin_codec=True) ErrorHolder = InternalImportPathHolder("ErrorHolder", "") ErrorHolderCodec = InternalImportPathHolder("ErrorHolderCodec", "", is_custom_codec=True) - IndexConfig = InternalImportPathHolder("IndexConfig", "/core") + IndexConfig = ImportPathHolder("IndexConfig", "/hztypes") IndexConfigCodec = InternalImportPathHolder("IndexConfigCodec", "", is_custom_codec=True) ListDataCodec = InternalImportPathHolder("ListDataCodec", "", is_builtin_codec=True) ListIntegerCodec = InternalImportPathHolder("ListIntegerCodec", "", is_builtin_codec=True) @@ -192,7 +192,7 @@ class PathHolders: # "EventJournalConfig": "NA", # "EvictionConfigHolder": "NA", # "HotRestartConfig": "NA", - # "IndexConfig": "config.IndexConfig", + "IndexConfig": "hztypes.IndexConfig", "Integer": "int32", # "List_CPMember": "NA", # "ListenerConfigHolder": "NA", @@ -243,13 +243,13 @@ class PathHolders: "EntryList_UUID_Long": "[]proto.Pair", "EntryList_UUID_UUID": "[]proto.Pair", # "ListCN_Data": "[]serialization.Data", - # "List_AttributeConfig": "NA", + "List_AttributeConfig": "NA", # "List_CacheEventData": "NA", # "List_CacheSimpleEntryListenerConfig": "NA", # "List_ClientBwListEntry": "NA", "List_Data": "[]serialization.Data", "List_DistributedObjectInfo": "[]internal.DistributedObjectInfo", - # "List_IndexConfig": "[]IndexConfig", + "List_IndexConfig": "[]hztypes.IndexConfig", "List_Integer": "[]int32", # "List_ListCN_Data": "NA", "List_List_Data": "[]serialization.Data", @@ -296,14 +296,14 @@ class PathHolders: "EntryList_UUID_Long": "[]proto.Pair", "EntryList_UUID_UUID": "[]proto.Pair", # "ListCN_Data": "[]serialization.Data", - # "List_AttributeConfig": "NA", + "List_AttributeConfig": "NA", # "List_CPMember": "NA", # "List_CacheEventData": "NA", # "List_CacheSimpleEntryListenerConfig": "NA", # "List_ClientBwListEntry": "NA", "List_Data": "[]serialization.Data", "List_DistributedObjectInfo": "[]internal.DistributedObjectInfo", - # "List_IndexConfig": "[]IndexConfig", + "List_IndexConfig": "[]hztypes.IndexConfig", "List_Integer": "[]int32", # "List_ListCN_Data": "NA", "List_List_Data": "[]serialization.Data", From b62f876ea1ea4cdbd097e94e183b136fdaf7850a Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Fri, 30 Jul 2021 10:10:18 +0300 Subject: [PATCH 21/41] updates --- go/__init__.py | 20 +-- go/verbatim/builtin.go | 284 +++++++++++++++++++++++++++++------------ 2 files changed, 214 insertions(+), 90 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index 510a8dd51..089a534d3 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -86,11 +86,11 @@ class PathHolders: AddressCodec = InternalImportPathHolder("AddressCodec", None, is_custom_codec=True) AnchorDataListHolder = InternalImportPathHolder("AnchorDataListHolder", "") AnchorDataListHolderCodec = InternalImportPathHolder("AnchorDataListHolderCodec", "", is_custom_codec=True) - BitmapIndexOptions = InternalImportPathHolder("BitmapIndexOptions", "") + BitmapIndexOptions = ImportPathHolder("BitmapIndexOptions", "/hztypes") BitmapIndexOptionsCodec = InternalImportPathHolder("BitmapIndexOptionsCodec", None, is_custom_codec=True) ByteArrayCodec = InternalImportPathHolder("ByteArrayCodec", "", is_builtin_codec=True) CodecUtilCodec = InternalImportPathHolder("CodecUtil", "", is_builtin_codec=True) - Data = InternalImportPathHolder('Data', '/serialization') + Data = ImportPathHolder('Data', '/serialization') DataCodec = InternalImportPathHolder("DataCodec", "", is_builtin_codec=True) DistributedObjectInfo = InternalImportPathHolder("DistributedObjectInfo", "") DistributedObjectInfoCodec = InternalImportPathHolder("DistributedObjectInfoCodec", None, is_custom_codec=True) @@ -123,7 +123,7 @@ class PathHolders: PagingPredicateHolderCodec = InternalImportPathHolder("PagingPredicateHolderCodec", "", is_custom_codec=True) RaftGroupId = InternalImportPathHolder("RaftGroupId", "") RaftGroupIdCodec = InternalImportPathHolder("RaftGroupIdCodec", "", is_custom_codec=True) - SimpleEntryView = InternalImportPathHolder("SimpleEntryView", "") + SimpleEntryView = ImportPathHolder("SimpleEntryView", "/hztypes") SimpleEntryViewCodec = InternalImportPathHolder("SimpleEntryViewCodec", None, is_custom_codec=True) StackTraceElement = ImportPathHolder("StackTraceElement", "/hzerror") StackTraceElementCodec = InternalImportPathHolder("StackTraceElementCodec", None, is_custom_codec=True) @@ -179,7 +179,7 @@ class PathHolders: _go_types_common = { "Address": "cluster.Address", # "AttributeConfig": "NA", - "BitmapIndexOptions": "internal.BitmapIndexOptions", + "BitmapIndexOptions": "hztypes.BitmapIndexOptions", # "CacheConfigHolder": "NA", # "CacheEventData": "NA", # "CacheSimpleEntryListenerConfig": "NA", @@ -188,7 +188,7 @@ class PathHolders: "DistributedObjectInfo": "internal.DistributedObjectInfo", # "DurationConfig": "NA", "EndpointQualifier": "internal.EndpointQualifier", - # "ErrorHolder": "proto.ErrorHolder", + "ErrorHolder": "proto.ErrorHolder", # "EventJournalConfig": "NA", # "EvictionConfigHolder": "NA", # "HotRestartConfig": "NA", @@ -211,7 +211,7 @@ class PathHolders: # "QueueStoreConfigHolder": "NA", # "RaftGroupId": "proto.RaftGroupId", # "RingbufferStoreConfigHolder": "NA", - "SimpleEntryView": "*internal.SimpleEntryView", + "SimpleEntryView": "*hztypes.SimpleEntryView", "StackTraceElement": "hzerror.StackTraceElement", "String": "string", # "TimedExpiryPolicyFactoryConfig": "NA", @@ -226,7 +226,7 @@ class PathHolders: } _go_types_encode = { - # "AnchorDataListHolder": "proto.AnchorDataListHolder", + "AnchorDataListHolder": "proto.AnchorDataListHolder", # "CPMember": "NA", # "CacheEventData": "NA", # "ClientBwListEntry": "NA", @@ -269,7 +269,7 @@ class PathHolders: "MemberInfo": "cluster.MemberInfo", "MemberVersion": "cluster.MemberVersion", # "MigrationState": "NA", - # "PagingPredicateHolder": "proto.PagingPredicateHolder", + "PagingPredicateHolder": "proto.PagingPredicateHolder", # "QueryCacheEventData": "NA", # "ScheduledTaskHandler": "NA", # "SqlColumnMetadata": "NA", @@ -279,7 +279,7 @@ class PathHolders: } _go_types_decode = { - # "AnchorDataListHolder": "proto.AnchorDataListHolder", + "AnchorDataListHolder": "proto.AnchorDataListHolder", # "CPMember": "NA", # "CacheEventData": "NA", # "ClientBwListEntry": "NA", @@ -315,7 +315,7 @@ class PathHolders: # "List_QueryCacheEventData": "NA", # "List_ScheduledTaskHandler": "NA", # "List_SqlColumnMetadata": "NA", - # "List_StackTraceElement": "[]proto.StackTraceElement", + "List_StackTraceElement": "[]hzerror.StackTraceElement", "List_String": "[]string", "List_UUID": "[]internal.UUID", # "List_Xid": "NA", diff --git a/go/verbatim/builtin.go b/go/verbatim/builtin.go index 922df5f01..880afb7d3 100644 --- a/go/verbatim/builtin.go +++ b/go/verbatim/builtin.go @@ -1,22 +1,40 @@ +/* + * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License") + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + package codec import ( "encoding/binary" - "github.com/hazelcast/hazelcast-go-client/v4/hazelcast/hzerror" + "fmt" + "net" + "strconv" "strings" - pubcluster "github.com/hazelcast/hazelcast-go-client/v4/hazelcast/cluster" - "github.com/hazelcast/hazelcast-go-client/v4/internal" - "github.com/hazelcast/hazelcast-go-client/v4/internal/proto" - "github.com/hazelcast/hazelcast-go-client/v4/internal/serialization" - "github.com/hazelcast/hazelcast-go-client/v4/internal/serialization/spi" + pubcluster "github.com/hazelcast/hazelcast-go-client/cluster" + ihzerrors "github.com/hazelcast/hazelcast-go-client/internal/hzerrors" + "github.com/hazelcast/hazelcast-go-client/internal/proto" + iserialization "github.com/hazelcast/hazelcast-go-client/internal/serialization" + "github.com/hazelcast/hazelcast-go-client/types" ) // Encoder for ClientMessage and value type Encoder func(message *proto.ClientMessage, value interface{}) -// Decoder create serialization.Data -type Decoder func(frameIterator *proto.ForwardFrameIterator) serialization.Data +// Decoder create *iserialization.Data +type Decoder func(frameIterator *proto.ForwardFrameIterator) *iserialization.Data // CodecUtil type codecUtil struct{} @@ -52,15 +70,15 @@ func (codecUtil) EncodeNullableForString(message *proto.ClientMessage, value str } } -func (codecUtil) EncodeNullableForBitmapIndexOptions(message *proto.ClientMessage, options internal.BitmapIndexOptions) { +func (codecUtil) EncodeNullableForBitmapIndexOptions(message *proto.ClientMessage, options *types.BitmapIndexOptions) { if options == nil { message.AddFrame(proto.NullFrame.Copy()) } else { - EncodeBitmapIndexOptions(message, options) + EncodeBitmapIndexOptions(message, *options) } } -func (codecUtil) EncodeNullableForData(message *proto.ClientMessage, data serialization.Data) { +func (codecUtil) EncodeNullableForData(message *proto.ClientMessage, data *iserialization.Data) { if data == nil { message.AddFrame(proto.NullFrame.Copy()) } else { @@ -68,29 +86,30 @@ func (codecUtil) EncodeNullableForData(message *proto.ClientMessage, data serial } } -func (codecUtil) DecodeNullableForData(frameIterator *proto.ForwardFrameIterator) serialization.Data { - if CodecUtil.NextFrameIsNullFrame(frameIterator) { +func (c codecUtil) DecodeNullableForData(frameIterator *proto.ForwardFrameIterator) *iserialization.Data { + if c.NextFrameIsNullFrame(frameIterator) { return nil } return DecodeData(frameIterator) } -func (codecUtil) DecodeNullableForAddress(frameIterator *proto.ForwardFrameIterator) pubcluster.Address { - if CodecUtil.NextFrameIsNullFrame(frameIterator) { +func (c codecUtil) DecodeNullableForAddress(frameIterator *proto.ForwardFrameIterator) *pubcluster.Address { + if c.NextFrameIsNullFrame(frameIterator) { return nil } - return DecodeAddress(frameIterator) + addr := DecodeAddress(frameIterator) + return &addr } -func (codecUtil) DecodeNullableForLongArray(frameIterator *proto.ForwardFrameIterator) []int64 { - if CodecUtil.NextFrameIsNullFrame(frameIterator) { +func (c codecUtil) DecodeNullableForLongArray(frameIterator *proto.ForwardFrameIterator) []int64 { + if c.NextFrameIsNullFrame(frameIterator) { return nil } return DecodeLongArray(frameIterator) } -func (codecUtil) DecodeNullableForString(frameIterator *proto.ForwardFrameIterator) string { - if CodecUtil.NextFrameIsNullFrame(frameIterator) { +func (c codecUtil) DecodeNullableForString(frameIterator *proto.ForwardFrameIterator) string { + if c.NextFrameIsNullFrame(frameIterator) { return "" } return DecodeString(frameIterator) @@ -108,18 +127,16 @@ func (codecUtil) NextFrameIsNullFrame(frameIterator *proto.ForwardFrameIterator) return isNullFrame } -func (codecUtil) DecodeNullableForBitmapIndexOptions(frameIterator *proto.ForwardFrameIterator) internal.BitmapIndexOptions { - isNullFrame := frameIterator.PeekNext().IsNullFrame() - if isNullFrame { - frameIterator.Next() +func (c codecUtil) DecodeNullableForBitmapIndexOptions(frameIterator *proto.ForwardFrameIterator) types.BitmapIndexOptions { + if c.NextFrameIsNullFrame(frameIterator) { + return types.BitmapIndexOptions{} } return DecodeBitmapIndexOptions(frameIterator) } -func (codecUtil) DecodeNullableForSimpleEntryView(frameIterator *proto.ForwardFrameIterator) *internal.SimpleEntryView { - isNullFrame := frameIterator.PeekNext().IsNullFrame() - if isNullFrame { - frameIterator.Next() +func (c codecUtil) DecodeNullableForSimpleEntryView(frameIterator *proto.ForwardFrameIterator) *types.SimpleEntryView { + if c.NextFrameIsNullFrame(frameIterator) { + return nil } return DecodeSimpleEntryView(frameIterator) } @@ -133,10 +150,10 @@ func DecodeByteArray(frameIterator *proto.ForwardFrameIterator) []byte { } func EncodeData(message *proto.ClientMessage, value interface{}) { - message.AddFrame(proto.NewFrame(value.(serialization.Data).ToByteArray())) + message.AddFrame(proto.NewFrame(value.(*iserialization.Data).ToByteArray())) } -func EncodeNullableData(message *proto.ClientMessage, data serialization.Data) { +func EncodeNullableData(message *proto.ClientMessage, data *iserialization.Data) { if data == nil { message.AddFrame(proto.NullFrame.Copy()) } else { @@ -144,11 +161,11 @@ func EncodeNullableData(message *proto.ClientMessage, data serialization.Data) { } } -func DecodeData(frameIterator *proto.ForwardFrameIterator) serialization.Data { - return spi.NewData(frameIterator.Next().Content) +func DecodeData(frameIterator *proto.ForwardFrameIterator) *iserialization.Data { + return iserialization.NewData(frameIterator.Next().Content) } -func DecodeNullableData(frameIterator *proto.ForwardFrameIterator) serialization.Data { +func DecodeNullableData(frameIterator *proto.ForwardFrameIterator) *iserialization.Data { if CodecUtil.NextFrameIsNullFrame(frameIterator) { return nil } @@ -196,7 +213,7 @@ func EncodeEntryListForDataAndListData(message *proto.ClientMessage, entries []p message.AddFrame(proto.BeginFrame.Copy()) for _, value := range entries { EncodeData(message, value.Key()) - EncodeListData(message, value.Value().([]serialization.Data)) + EncodeListData(message, value.Value().([]*iserialization.Data)) } message.AddFrame(proto.EndFrame.Copy()) } @@ -279,7 +296,7 @@ func EncodeEntryListUUIDLong(message *proto.ClientMessage, entries []proto.Pair) content := make([]byte, size*proto.EntrySizeInBytes) newFrame := proto.NewFrame(content) for i, entry := range entries { - key := entry.Key().(internal.UUID) + key := entry.Key().(types.UUID) value := entry.Value().(int64) FixSizedTypesCodec.EncodeUUID(content, int32(i*proto.EntrySizeInBytes), key) FixSizedTypesCodec.EncodeLong(content, int32(i*proto.EntrySizeInBytes+proto.UUIDSizeInBytes), value) @@ -326,16 +343,16 @@ func DecodeEntryListIntegerInteger(frameIterator *proto.ForwardFrameIterator) [] func EncodeEntryListUUIDListInteger(message *proto.ClientMessage, entries []proto.Pair) { entryCount := len(entries) - uuids := make([]internal.UUID, entryCount) - message.AddFrame(proto.BeginFrame) + uuids := make([]types.UUID, entryCount) + message.AddFrame(proto.NewBeginFrame()) for i := 0; i < entryCount; i++ { entry := entries[i] - key := entry.Key().(internal.UUID) + key := entry.Key().(types.UUID) value := entry.Value().([]int32) uuids[i] = key EncodeListInteger(message, value) } - message.AddFrame(proto.EndFrame) + message.AddFrame(proto.NewEndFrame()) EncodeListUUID(message, uuids) } @@ -415,8 +432,8 @@ func (fixSizedTypesCodec) DecodeByte(buffer []byte, offset int32) byte { return buffer[offset] } -func (fixSizedTypesCodec) EncodeUUID(buffer []byte, offset int32, uuid internal.UUID) { - isNullEncode := uuid == nil +func (fixSizedTypesCodec) EncodeUUID(buffer []byte, offset int32, uuid types.UUID) { + isNullEncode := uuid.Default() FixSizedTypesCodec.EncodeBoolean(buffer, offset, isNullEncode) if isNullEncode { return @@ -426,10 +443,10 @@ func (fixSizedTypesCodec) EncodeUUID(buffer []byte, offset int32, uuid internal. FixSizedTypesCodec.EncodeLong(buffer, bufferOffset+proto.LongSizeInBytes, int64(uuid.LeastSignificantBits())) } -func (fixSizedTypesCodec) DecodeUUID(buffer []byte, offset int32) internal.UUID { +func (fixSizedTypesCodec) DecodeUUID(buffer []byte, offset int32) types.UUID { isNull := FixSizedTypesCodec.DecodeBoolean(buffer, offset) if isNull { - return nil + return types.UUID{} } mostSignificantOffset := offset + proto.BooleanSizeInBytes @@ -437,7 +454,7 @@ func (fixSizedTypesCodec) DecodeUUID(buffer []byte, offset int32) internal.UUID mostSignificant := uint64(FixSizedTypesCodec.DecodeLong(buffer, mostSignificantOffset)) leastSignificant := uint64(FixSizedTypesCodec.DecodeLong(buffer, leastSignificantOffset)) - return internal.NewUUIDWith(mostSignificant, leastSignificant) + return types.NewUUIDWith(mostSignificant, leastSignificant) } func EncodeListInteger(message *proto.ClientMessage, entries []int32) { @@ -479,40 +496,40 @@ func DecodeListLong(frameIterator *proto.ForwardFrameIterator) []int64 { return result } -func EncodeListMultiFrame(message *proto.ClientMessage, values []serialization.Data, encoder Encoder) { - message.AddFrame(proto.BeginFrame) +func EncodeListMultiFrame(message *proto.ClientMessage, values []*iserialization.Data, encoder Encoder) { + message.AddFrame(proto.NewBeginFrame()) for i := 0; i < len(values); i++ { encoder(message, values[i]) } - message.AddFrame(proto.EndFrame) + message.AddFrame(proto.NewEndFrame()) } -func EncodeListMultiFrameForData(message *proto.ClientMessage, values []serialization.Data) { - message.AddFrame(proto.BeginFrame) +func EncodeListMultiFrameForData(message *proto.ClientMessage, values []*iserialization.Data) { + message.AddFrame(proto.NewBeginFrame()) for i := 0; i < len(values); i++ { EncodeData(message, values[i]) } - message.AddFrame(proto.EndFrame) + message.AddFrame(proto.NewEndFrame()) } func EncodeListMultiFrameForString(message *proto.ClientMessage, values []string) { - message.AddFrame(proto.BeginFrame) + message.AddFrame(proto.NewBeginFrame()) for i := 0; i < len(values); i++ { EncodeString(message, values[i]) } - message.AddFrame(proto.EndFrame) + message.AddFrame(proto.NewEndFrame()) } -func EncodeListMultiFrameForStackTraceElement(message *proto.ClientMessage, values []proto.StackTraceElement) { - message.AddFrame(proto.BeginFrame) +func EncodeListMultiFrameForStackTraceElement(message *proto.ClientMessage, values []ihzerrors.StackTraceElement) { + message.AddFrame(proto.NewBeginFrame()) for i := 0; i < len(values); i++ { EncodeStackTraceElement(message, values[i]) } - message.AddFrame(proto.EndFrame) + message.AddFrame(proto.NewEndFrame()) } -func EncodeListMultiFrameContainsNullable(message *proto.ClientMessage, values []serialization.Data, encoder Encoder) { - message.AddFrame(proto.BeginFrame) +func EncodeListMultiFrameContainsNullable(message *proto.ClientMessage, values []*iserialization.Data, encoder Encoder) { + message.AddFrame(proto.NewBeginFrame()) for i := 0; i < len(values); i++ { if values[i] == nil { message.AddFrame(proto.NullFrame) @@ -520,10 +537,10 @@ func EncodeListMultiFrameContainsNullable(message *proto.ClientMessage, values [ encoder(message, values[i]) } } - message.AddFrame(proto.EndFrame) + message.AddFrame(proto.NewEndFrame()) } -func EncodeListMultiFrameNullable(message *proto.ClientMessage, values []serialization.Data, encoder Encoder) { +func EncodeListMultiFrameNullable(message *proto.ClientMessage, values []*iserialization.Data, encoder Encoder) { if len(values) == 0 { message.AddFrame(proto.NullFrame) } else { @@ -531,31 +548,29 @@ func EncodeListMultiFrameNullable(message *proto.ClientMessage, values []seriali } } -func DecodeListMultiFrameForData(frameIterator *proto.ForwardFrameIterator) []serialization.Data { - result := make([]serialization.Data, 0) +func DecodeListMultiFrame(frameIterator *proto.ForwardFrameIterator, decoder func(frameIterator *proto.ForwardFrameIterator)) { frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { - result = append(result, DecodeData(frameIterator)) + decoder(frameIterator) } frameIterator.Next() - return result } -func DecodeListMultiFrameWithListInteger(frameIterator *proto.ForwardFrameIterator) []int32 { - result := make([]int32, 0) +func DecodeListMultiFrameForData(frameIterator *proto.ForwardFrameIterator) []*iserialization.Data { + result := make([]*iserialization.Data, 0) frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { - result = append(result, DecodeListInteger(frameIterator)...) + result = append(result, DecodeData(frameIterator)) } frameIterator.Next() return result } -func DecodeListMultiFrameForDistributedObjectInfo(frameIterator *proto.ForwardFrameIterator) []internal.DistributedObjectInfo { - result := make([]internal.DistributedObjectInfo, 0) +func DecodeListMultiFrameWithListInteger(frameIterator *proto.ForwardFrameIterator) []int32 { + result := make([]int32, 0) frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { - result = append(result, DecodeDistributedObjectInfo(frameIterator)) + result = append(result, DecodeListInteger(frameIterator)...) } frameIterator.Next() return result @@ -571,8 +586,8 @@ func DecodeListMultiFrameForMemberInfo(frameIterator *proto.ForwardFrameIterator return result } -func DecodeListMultiFrameForStackTraceElement(frameIterator *proto.ForwardFrameIterator) []hzerror.StackTraceElement { - result := make([]hzerror.StackTraceElement, 0) +func DecodeListMultiFrameForStackTraceElement(frameIterator *proto.ForwardFrameIterator) []ihzerrors.StackTraceElement { + var result []ihzerrors.StackTraceElement frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { result = append(result, DecodeStackTraceElement(frameIterator)) @@ -591,8 +606,8 @@ func DecodeListMultiFrameForString(frameIterator *proto.ForwardFrameIterator) [] return result } -func DecodeListMultiFrameForDataContainsNullable(frameIterator *proto.ForwardFrameIterator) []serialization.Data { - result := make([]serialization.Data, 0) +func DecodeListMultiFrameForDataContainsNullable(frameIterator *proto.ForwardFrameIterator) []*iserialization.Data { + result := make([]*iserialization.Data, 0) frameIterator.Next() for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { if CodecUtil.NextFrameIsNullFrame(frameIterator) { @@ -605,15 +620,15 @@ func DecodeListMultiFrameForDataContainsNullable(frameIterator *proto.ForwardFra return result } -func EncodeListData(message *proto.ClientMessage, entries []serialization.Data) { +func EncodeListData(message *proto.ClientMessage, entries []*iserialization.Data) { EncodeListMultiFrameForData(message, entries) } -func DecodeListData(frameIterator *proto.ForwardFrameIterator) []serialization.Data { +func DecodeListData(frameIterator *proto.ForwardFrameIterator) []*iserialization.Data { return DecodeListMultiFrameForData(frameIterator) } -func EncodeListUUID(message *proto.ClientMessage, entries []internal.UUID) { +func EncodeListUUID(message *proto.ClientMessage, entries []types.UUID) { itemCount := len(entries) content := make([]byte, itemCount*proto.UUIDSizeInBytes) newFrame := proto.NewFrame(content) @@ -623,10 +638,10 @@ func EncodeListUUID(message *proto.ClientMessage, entries []internal.UUID) { message.AddFrame(newFrame) } -func DecodeListUUID(frameIterator *proto.ForwardFrameIterator) []internal.UUID { +func DecodeListUUID(frameIterator *proto.ForwardFrameIterator) []types.UUID { frame := frameIterator.Next() itemCount := len(frame.Content) / proto.UUIDSizeInBytes - result := make([]internal.UUID, itemCount) + result := make([]types.UUID, itemCount) for i := 0; i < itemCount; i++ { result[i] = FixSizedTypesCodec.DecodeUUID(frame.Content, int32(i*proto.UUIDSizeInBytes)) } @@ -661,7 +676,7 @@ func EncodeMapForStringAndString(message *proto.ClientMessage, values map[string message.AddFrame(proto.EndFrame.Copy()) } -func EncodeMapForEndpointQualifierAndAddress(message *proto.ClientMessage, values map[internal.EndpointQualifier]pubcluster.Address) { +func EncodeMapForEndpointQualifierAndAddress(message *proto.ClientMessage, values map[pubcluster.EndpointQualifier]pubcluster.Address) { message.AddFrame(proto.BeginFrame.Copy()) for key, value := range values { EncodeEndpointQualifier(message, key) @@ -683,7 +698,7 @@ func DecodeMapForStringAndString(iterator *proto.ForwardFrameIterator) map[strin } func DecodeMapForEndpointQualifierAndAddress(iterator *proto.ForwardFrameIterator) interface{} { - result := map[internal.EndpointQualifier]pubcluster.Address{} + result := map[pubcluster.EndpointQualifier]pubcluster.Address{} iterator.Next() for !iterator.PeekNext().IsEndFrame() { key := DecodeEndpointQualifier(iterator) @@ -701,3 +716,112 @@ func EncodeString(message *proto.ClientMessage, value interface{}) { func DecodeString(frameIterator *proto.ForwardFrameIterator) string { return string(frameIterator.Next().Content) } + +func DecodeError(msg *proto.ClientMessage) *ihzerrors.ServerError { + frameIterator := msg.FrameIterator() + frameIterator.Next() + errorHolders := []proto.ErrorHolder{} + DecodeListMultiFrame(frameIterator, func(it *proto.ForwardFrameIterator) { + errorHolders = append(errorHolders, DecodeErrorHolder(frameIterator)) + }) + if len(errorHolders) == 0 { + return nil + } + holder := errorHolders[0] + return ihzerrors.NewServerError(holder.ErrorCode, holder.ClassName, holder.Message, holder.StackTraceElements) +} + +func NewEndpointQualifier(qualifierType int32, identifier string) pubcluster.EndpointQualifier { + return pubcluster.EndpointQualifier{ + Type: pubcluster.EndpointQualifierType(qualifierType), + Identifier: identifier, + } +} + +// DistributedObject is the base interface for all distributed objects. +type DistributedObject interface { + // Destroy destroys this object cluster-wide. + // Destroy clears and releases all resources for this object. + Destroy() (bool, error) + + // Name returns the unique name for this DistributedObject. + Name() string + + // PartitionKey returns the key of partition this DistributedObject is assigned to. The returned value only has meaning + // for a non partitioned data structure like an IAtomicLong. For a partitioned data structure like an Map + // the returned value will not be nil, but otherwise undefined. + PartitionKey() string + + // ServiceName returns the service name for this object. + ServiceName() string +} + +type DistributedObjectInfo struct { + name string + serviceName string +} + +func (i *DistributedObjectInfo) Name() string { + return i.name +} + +func (i *DistributedObjectInfo) ServiceName() string { + return i.serviceName +} + +func (i *DistributedObjectInfo) GetName() string { + return i.name +} + +func (i *DistributedObjectInfo) GetServiceName() string { + return i.serviceName +} + +func NewDistributedObjectInfo(name string, serviceName string) DistributedObjectInfo { + return DistributedObjectInfo{name: name, serviceName: serviceName} +} + +func NewMemberVersion(major, minor, patch byte) pubcluster.MemberVersion { + return pubcluster.MemberVersion{Major: major, Minor: minor, Patch: patch} +} + +func NewMemberInfo( + address pubcluster.Address, + uuid types.UUID, + attributes map[string]string, + liteMember bool, + version pubcluster.MemberVersion, + addressMapExists bool, + addressMap interface{}) pubcluster.MemberInfo { + var addrMap map[pubcluster.EndpointQualifier]pubcluster.Address + if addressMapExists { + addrMap = addressMap.(map[pubcluster.EndpointQualifier]pubcluster.Address) + } else { + addrMap = map[pubcluster.EndpointQualifier]pubcluster.Address{} + } + return pubcluster.MemberInfo{ + Address: address, + UUID: uuid, + Attributes: attributes, + LiteMember: liteMember, + Version: version, + AddressMap: addrMap, + } +} + +func EncodeAddress(clientMessage *proto.ClientMessage, address pubcluster.Address) { + host, portStr, err := net.SplitHostPort(address.String()) + if err != nil { + panic(fmt.Errorf("parsing address: %w", err)) + } + port, err := strconv.Atoi(portStr) + if err != nil { + panic(fmt.Errorf("parsing address: %w", err)) + } + clientMessage.AddFrame(proto.BeginFrame.Copy()) + initialFrame := proto.NewFrame(make([]byte, AddressCodecPortInitialFrameSize)) + FixSizedTypesCodec.EncodeInt(initialFrame.Content, AddressCodecPortFieldOffset, int32(port)) + clientMessage.AddFrame(initialFrame) + EncodeString(clientMessage, host) + clientMessage.AddFrame(proto.EndFrame.Copy()) +} From de5fcf4c4676371235bd640e048fec6fdc15c701 Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Wed, 22 Sep 2021 06:16:00 +0300 Subject: [PATCH 22/41] updates --- go/__init__.py | 119 +++++++++++------ go/codec-template.go.j2 | 43 +++--- go/custom-codec-template.go.j2 | 233 +++++++++++++++++---------------- go/verbatim/builtin.go | 43 +++--- go/verbatim/builtin_test.go | 126 ++++++++++-------- util.py | 11 +- 6 files changed, 315 insertions(+), 260 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index 089a534d3..c7cd889f3 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -1,5 +1,3 @@ -CLIENT_VERSION = 4 - go_reserved_keywords = {"break", "default", "func", "interface", "select", "case", "defer", "go", "map", "struct", "chan", "else", "goto", "package", "switch", "const", "fallthrough", "if", "range", "type", "continue", "for", "import", "return", "var"} @@ -13,7 +11,7 @@ def go_escape_keyword(value): if value not in go_reserved_keywords: return value - return "_" + value + return "_%s" % value def go_types_encode(key): @@ -54,7 +52,10 @@ def go_get_import_statements(*args): path = path_holder.import_statement if path is not None: import_statements.add(path) - return import_statements + import_statements.add('"github.com/hazelcast/hazelcast-go-client/internal/proto"') + if args[0] == "SimpleEntryView": + import_statements.remove('iserialization"github.com/hazelcast/hazelcast-go-client/internal/serialization"') + return sorted(import_statements) class ImportPathHolder: @@ -66,19 +67,21 @@ def __init__(self, name, path, is_builtin_codec=False, is_custom_codec=False): def import_statement(self): if not self.path: return "" - return '''"github.com/hazelcast/hazelcast-go-client/v%s/hazelcast%s"''' % (CLIENT_VERSION, self.path) + return '''"github.com/hazelcast/hazelcast-go-client%s"''' % self.path class InternalImportPathHolder: - def __init__(self, name, path, is_builtin_codec=False, is_custom_codec=False): + def __init__(self, name, path, alias="", is_builtin_codec=False, is_custom_codec=False): self.name = name self.path = path + self.alias = alias @property def import_statement(self): if self.path is None: return "" - return '''"github.com/hazelcast/hazelcast-go-client/v%s/internal%s"''' % (CLIENT_VERSION, self.path) + alias = "%s " % self.alias if self.alias else "" + return '''%s"github.com/hazelcast/hazelcast-go-client/internal%s"''' % (self.alias, self.path) class PathHolders: @@ -86,15 +89,15 @@ class PathHolders: AddressCodec = InternalImportPathHolder("AddressCodec", None, is_custom_codec=True) AnchorDataListHolder = InternalImportPathHolder("AnchorDataListHolder", "") AnchorDataListHolderCodec = InternalImportPathHolder("AnchorDataListHolderCodec", "", is_custom_codec=True) - BitmapIndexOptions = ImportPathHolder("BitmapIndexOptions", "/hztypes") + BitmapIndexOptions = ImportPathHolder("BitmapIndexOptions", "/types") BitmapIndexOptionsCodec = InternalImportPathHolder("BitmapIndexOptionsCodec", None, is_custom_codec=True) ByteArrayCodec = InternalImportPathHolder("ByteArrayCodec", "", is_builtin_codec=True) CodecUtilCodec = InternalImportPathHolder("CodecUtil", "", is_builtin_codec=True) - Data = ImportPathHolder('Data', '/serialization') + Data = InternalImportPathHolder('Data', '/serialization', 'iserialization') DataCodec = InternalImportPathHolder("DataCodec", "", is_builtin_codec=True) - DistributedObjectInfo = InternalImportPathHolder("DistributedObjectInfo", "") + DistributedObjectInfo = ImportPathHolder("DistributedObjectInfo", "/types") DistributedObjectInfoCodec = InternalImportPathHolder("DistributedObjectInfoCodec", None, is_custom_codec=True) - EndpointQualifier = InternalImportPathHolder("EndpointQualifier", "") + EndpointQualifier = ImportPathHolder("EndpointQualifier", "/cluster") EndpointQualifierCodec = InternalImportPathHolder("EndpointQualifierCodec", None, is_custom_codec=True) EntryListCodec = InternalImportPathHolder("EntryListCodec", "", is_builtin_codec=True) EntryListIntegerIntegerCodec = InternalImportPathHolder("EntryListIntegerIntegerCodec", "", is_builtin_codec=True) @@ -104,9 +107,9 @@ class PathHolders: EntryListUUIDListIntegerCodec = InternalImportPathHolder("EntryListUUIDListIntegerCodec", "", is_builtin_codec=True) EntryListUUIDLongCodec = InternalImportPathHolder("EntryListUUIDLongCodec", "", is_builtin_codec=True) EntryListUUIDUUIDCodec = InternalImportPathHolder("EntryListUUIDUUIDCodec", "", is_builtin_codec=True) - ErrorHolder = InternalImportPathHolder("ErrorHolder", "") + ErrorHolder = InternalImportPathHolder("ErrorHolder", "/proto") ErrorHolderCodec = InternalImportPathHolder("ErrorHolderCodec", "", is_custom_codec=True) - IndexConfig = ImportPathHolder("IndexConfig", "/hztypes") + IndexConfig = ImportPathHolder("IndexConfig", "/types") IndexConfigCodec = InternalImportPathHolder("IndexConfigCodec", "", is_custom_codec=True) ListDataCodec = InternalImportPathHolder("ListDataCodec", "", is_builtin_codec=True) ListIntegerCodec = InternalImportPathHolder("ListIntegerCodec", "", is_builtin_codec=True) @@ -123,12 +126,12 @@ class PathHolders: PagingPredicateHolderCodec = InternalImportPathHolder("PagingPredicateHolderCodec", "", is_custom_codec=True) RaftGroupId = InternalImportPathHolder("RaftGroupId", "") RaftGroupIdCodec = InternalImportPathHolder("RaftGroupIdCodec", "", is_custom_codec=True) - SimpleEntryView = ImportPathHolder("SimpleEntryView", "/hztypes") + SimpleEntryView = ImportPathHolder("SimpleEntryView", "/types") SimpleEntryViewCodec = InternalImportPathHolder("SimpleEntryViewCodec", None, is_custom_codec=True) - StackTraceElement = ImportPathHolder("StackTraceElement", "/hzerror") + StackTraceElement = InternalImportPathHolder("StackTraceElement", "/hzerrors", alias="ihzerrors") StackTraceElementCodec = InternalImportPathHolder("StackTraceElementCodec", None, is_custom_codec=True) StringCodec = InternalImportPathHolder("StringCodec", None, is_builtin_codec=True) - UUID = InternalImportPathHolder("UUID", "") + UUID = ImportPathHolder("UUID", "/types") import_paths = { @@ -138,6 +141,7 @@ class PathHolders: "CodecUtil": PathHolders.CodecUtilCodec, "Data": [PathHolders.Data, PathHolders.DataCodec], "DistributedObjectInfo": [PathHolders.DistributedObjectInfo, PathHolders.DistributedObjectInfoCodec], + "EndpointQualifier": [PathHolders.EndpointQualifier], "EntryList_Data_Data": [PathHolders.EntryListCodec, PathHolders.DataCodec], "EntryList_Data_List_Data": [PathHolders.EntryListCodec, PathHolders.DataCodec, PathHolders.ListDataCodec], "EntryList_Integer_Integer": [PathHolders.EntryListIntegerIntegerCodec], @@ -155,7 +159,7 @@ class PathHolders: "ListCN_Data": [PathHolders.ListMultiFrameCodec, PathHolders.DataCodec], "ListIndexConfig": [PathHolders.IndexConfigCodec, PathHolders.ListMultiFrameCodec], "List_Data": [PathHolders.Data, PathHolders.ListMultiFrameCodec, PathHolders.DataCodec], - "List_DistributedObjectInfo": [PathHolders.ListMultiFrameCodec, PathHolders.DistributedObjectInfoCodec], + "List_DistributedObjectInfo": [PathHolders.ListMultiFrameCodec, PathHolders.DistributedObjectInfo, PathHolders.DistributedObjectInfoCodec], "List_Integer": [PathHolders.ListIntegerCodec], "List_Long": [PathHolders.ListLongCodec], "List_StackTraceElement": [PathHolders.ListMultiFrameCodec, PathHolders.StackTraceElementCodec], @@ -178,27 +182,28 @@ class PathHolders: _go_types_common = { "Address": "cluster.Address", + "AnchorDataListHolder": "NA", # "AttributeConfig": "NA", - "BitmapIndexOptions": "hztypes.BitmapIndexOptions", + "BitmapIndexOptions": "types.BitmapIndexOptions", # "CacheConfigHolder": "NA", # "CacheEventData": "NA", # "CacheSimpleEntryListenerConfig": "NA", # "ClientBwListEntry": "NA", - "Data": "serialization.Data", - "DistributedObjectInfo": "internal.DistributedObjectInfo", + "Data": "*iserialization.Data", + "DistributedObjectInfo": "types.DistributedObjectInfo", # "DurationConfig": "NA", - "EndpointQualifier": "internal.EndpointQualifier", + "EndpointQualifier": "cluster.EndpointQualifier", "ErrorHolder": "proto.ErrorHolder", # "EventJournalConfig": "NA", # "EvictionConfigHolder": "NA", # "HotRestartConfig": "NA", - "IndexConfig": "hztypes.IndexConfig", + "IndexConfig": "types.IndexConfig", "Integer": "int32", # "List_CPMember": "NA", # "ListenerConfigHolder": "NA", "Long": "int64", # "MapStoreConfigHolder": "NA", - "Map_EndpointQualifier_Address": "map[internal.EndpointQualifier]cluster.Address", + "Map_EndpointQualifier_Address": "map[cluster.EndpointQualifier]cluster.Address", "Map_String_String": "map[string]string", "MemberInfo": "cluster.MemberInfo", # "MergePolicyConfig": "NA", @@ -211,11 +216,11 @@ class PathHolders: # "QueueStoreConfigHolder": "NA", # "RaftGroupId": "proto.RaftGroupId", # "RingbufferStoreConfigHolder": "NA", - "SimpleEntryView": "*hztypes.SimpleEntryView", - "StackTraceElement": "hzerror.StackTraceElement", + "SimpleEntryView": "*types.SimpleEntryView", + "StackTraceElement": "ihzerrors.StackTraceElement", "String": "string", # "TimedExpiryPolicyFactoryConfig": "NA", - "UUID": "internal.UUID", + "UUID": "types.UUID", # "WanReplicationRef": "NA", "boolean": "bool", "byte": "byte", @@ -226,7 +231,8 @@ class PathHolders: } _go_types_encode = { - "AnchorDataListHolder": "proto.AnchorDataListHolder", + # "AnchorDataListHolder": "proto.AnchorDataListHolder", + "AnchorDataListHolder": "NA", # "CPMember": "NA", # "CacheEventData": "NA", # "ClientBwListEntry": "NA", @@ -242,17 +248,17 @@ class PathHolders: "EntryList_UUID_List_Integer": "[]proto.Pair", "EntryList_UUID_Long": "[]proto.Pair", "EntryList_UUID_UUID": "[]proto.Pair", - # "ListCN_Data": "[]serialization.Data", + # "ListCN_Data": "[]*iserialization.Data", "List_AttributeConfig": "NA", # "List_CacheEventData": "NA", # "List_CacheSimpleEntryListenerConfig": "NA", # "List_ClientBwListEntry": "NA", - "List_Data": "[]serialization.Data", - "List_DistributedObjectInfo": "[]internal.DistributedObjectInfo", - "List_IndexConfig": "[]hztypes.IndexConfig", + "List_Data": "[]*iserialization.Data", + "List_DistributedObjectInfo": "[]types.DistributedObjectInfo", + "List_IndexConfig": "[]types.IndexConfig", "List_Integer": "[]int32", # "List_ListCN_Data": "NA", - "List_List_Data": "[]serialization.Data", + "List_List_Data": "[]*iserialization.Data", # "List_ListenerConfigHolder": "NA", "List_Long": "[]int64", # "List_MCEvent": "NA", @@ -261,15 +267,16 @@ class PathHolders: # "List_QueryCacheEventData": "NA", # "List_ScheduledTaskHandler": "NA", # "List_SqlColumnMetadata": "NA", - "List_StackTraceElement": "[]hzerror.StackTraceElement", + "List_StackTraceElement": "[]ihzerrors.StackTraceElement", "List_String": "[]string", - "List_UUID": "[]internal.UUID", + "List_UUID": "[]types.UUID", # "List_Xid": "NA", # "MCEvent": "NA", "MemberInfo": "cluster.MemberInfo", "MemberVersion": "cluster.MemberVersion", # "MigrationState": "NA", - "PagingPredicateHolder": "proto.PagingPredicateHolder", + # "PagingPredicateHolder": "proto.PagingPredicateHolder", + "PagingPredicateHolder": "NA", # "QueryCacheEventData": "NA", # "ScheduledTaskHandler": "NA", # "SqlColumnMetadata": "NA", @@ -279,7 +286,7 @@ class PathHolders: } _go_types_decode = { - "AnchorDataListHolder": "proto.AnchorDataListHolder", + # "Address": "cluster.Address", # "CPMember": "NA", # "CacheEventData": "NA", # "ClientBwListEntry": "NA", @@ -295,18 +302,18 @@ class PathHolders: "EntryList_UUID_List_Integer": "[]proto.Pair", "EntryList_UUID_Long": "[]proto.Pair", "EntryList_UUID_UUID": "[]proto.Pair", - # "ListCN_Data": "[]serialization.Data", + # "ListCN_Data": "[]*iserialization.Data", "List_AttributeConfig": "NA", # "List_CPMember": "NA", # "List_CacheEventData": "NA", # "List_CacheSimpleEntryListenerConfig": "NA", # "List_ClientBwListEntry": "NA", - "List_Data": "[]serialization.Data", - "List_DistributedObjectInfo": "[]internal.DistributedObjectInfo", - "List_IndexConfig": "[]hztypes.IndexConfig", + "List_Data": "[]*iserialization.Data", + "List_DistributedObjectInfo": "[]types.DistributedObjectInfo", + "List_IndexConfig": "[]types.IndexConfig", "List_Integer": "[]int32", # "List_ListCN_Data": "NA", - "List_List_Data": "[]serialization.Data", + "List_List_Data": "[]*iserialization.Data", # "List_ListenerConfigHolder": "NA", "List_Long": "[]int64", # "List_MCEvent": "NA", @@ -315,9 +322,9 @@ class PathHolders: # "List_QueryCacheEventData": "NA", # "List_ScheduledTaskHandler": "NA", # "List_SqlColumnMetadata": "NA", - "List_StackTraceElement": "[]hzerror.StackTraceElement", + "List_StackTraceElement": "[]ihzerrors.StackTraceElement", "List_String": "[]string", - "List_UUID": "[]internal.UUID", + "List_UUID": "[]types.UUID", # "List_Xid": "NA", # "MCEvent": "NA", "MemberInfo": "cluster.MemberInfo", @@ -331,3 +338,29 @@ class PathHolders: # "SqlQueryId": "NA", # "Xid": "NA", } + + +def go_augment_enum(codec, param): + cast_type = _go_enum.get((codec, param["name"])) + if cast_type: + return "%s(%s)" % (cast_type, go_escape_keyword(param["name"])) + return go_escape_keyword(param["name"]) + + +_go_enum = { + ("BitmapIndexOptions", "uniqueKeyTransformation"): "types.UniqueKeyTransformation", + ("EndpointQualifier", "type"): "cluster.EndpointQualifierType", + ("IndexConfig", "type"): "types.IndexType", +} + +def go_rename_field(codec, param): + name = param["name"] + field_name = _go_field.get((codec, name)) + if field_name: + return field_name + return "%s%s" % (name[0].upper(), name[1:]) + +_go_field = { + ("SimpleEntryView", "ttl"): "TTL", + ("MemberInfo", "uuid"): "UUID", +} \ No newline at end of file diff --git a/go/codec-template.go.j2 b/go/codec-template.go.j2 index 1e82c2743..667b29d27 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.go.j2 @@ -33,8 +33,7 @@ {%- endif -%} {%- endmacro %} {% macro insert_import_statements(stmts) %} -import ( - "github.com/hazelcast/hazelcast-go-client/v4/internal/proto" +import ( {% for stmt in stmts %} {{ stmt }} {% endfor %} @@ -53,19 +52,22 @@ import ( {% do event_var_sized_params.extend(var_size_params(event.params)) %} {% endfor %} {% endif %} -// Copyright (c) 2008-2020, Hazelcast, Inc. All Rights Reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. +/* +* Copyright (c) 2008-2020, Hazelcast, Inc. All Rights Reserved. +* +* Licensed under the Apache License, Version 2.0 (the "License") +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + package codec {{ insert_import_statements( @@ -80,14 +82,11 @@ package codec )}} const( - // hex: {{ '0x%06X'|format(method.request.id) }} - {{ service_name|capital }}{{ method.name|capital }}CodecRequestMessageType = int32({{ method.request.id }}) - // hex: {{ '0x%06X'|format(method.response.id) }} - {{ service_name|capital }}{{ method.name|capital }}CodecResponseMessageType = int32({{ method.response.id }}) + {{ service_name|capital }}{{ method.name|capital }}CodecRequestMessageType = int32({{ '0x%06X'|format(method.request.id) }}) + {{ service_name|capital }}{{ method.name|capital }}CodecResponseMessageType = int32({{ '0x%06X'|format(method.response.id) }}) {% for event in method.events%} - // hex: {{ '0x%06X'|format(event.id) }} - {{ service_name|capital }}{{ method.name|capital }}CodecEvent{{ event.name|capital }}MessageType = int32({{ event.id }}) + {{ service_name|capital }}{{ method.name|capital }}CodecEvent{{ event.name|capital }}MessageType = int32({{ '0x%06X'|format(event.id) }}) {% endfor %} {#FIXED SIZED PARAMETER OFFSET CONSTANTS#} @@ -201,7 +200,7 @@ func Decode{{ service_name|capital }}{{ method.name|capital }}Response(clientMes {# EVENTS#} {% if method.events|length != 0 %} -func Handle{{ service_name|capital }}{{ method.name|capital }}(clientMessage *proto.ClientMessage, {% for event in method.events%}handle{{ event.name|capital }}Event func({% for param in event.params %}{% if param in new_event_params %}is{{ param.name|capital }}Exists, {% endif %}{{param.name}} {{ lang_types_encode(param.type) }}{% if not loop.last %}, {% endif %}{% endfor %}){% if not loop.last %}, {% endif %}{% endfor %}){ +func Handle{{ service_name|capital }}{{ method.name|capital }}(clientMessage *proto.ClientMessage, {% for event in method.events%}handle{{ event.name|capital }}Event func({% for param in event.params %}{{param.name}} {{ lang_types_encode(param.type) }}{% if not loop.last %}, {% endif %}{% endfor %}){% if not loop.last %}, {% endif %}{% endfor %}){ messageType := clientMessage.Type() frameIterator := clientMessage.FrameIterator() {% for event in method.events%} diff --git a/go/custom-codec-template.go.j2 b/go/custom-codec-template.go.j2 index fdb568b3c..70b53c456 100644 --- a/go/custom-codec-template.go.j2 +++ b/go/custom-codec-template.go.j2 @@ -1,39 +1,38 @@ {% macro encode_var_sized(param) -%} - {% if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - Encode{% if param.nullable %}Nullable{% endif %}ListMultiFrame{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}For{{ item_type(lang_name, param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}()) - {%- elif is_var_sized_entry_list(param.type) -%} - Encode{% if param.nullable %}Nullable{% endif %}EntryListFor{{ value_type(lang_name, param.type) }}And{{ key_type(lang_name, param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}()) - {%- elif is_var_sized_map(param.type) -%} - Encode{% if param.nullable %}Nullable{% endif %}MapFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}()) - {%- else -%} - {%- if param.nullable -%} - CodecUtil.EncodeNullableFor{{ lang_name(param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}()) - {%- else -%} - Encode{{ lang_name(param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}()) - {%- endif %} - {% endif %} + {% if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} + Encode{% if param.nullable %}Nullable{% endif %}ListMultiFrame{% if is_var_sized_list_contains_nullable(param.type)%}ContainsNullable{% endif %}For{{ item_type(lang_name, param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}) + {%- elif is_var_sized_entry_list(param.type) -%} + Encode{% if param.nullable %}Nullable{% endif %}EntryListFor{{ value_type(lang_name, param.type) }}And{{ key_type(lang_name, param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}) + {%- elif is_var_sized_map(param.type) -%} + Encode{% if param.nullable %}Nullable{% endif %}MapFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}) + {%- else -%} + {%- if param.nullable -%} + CodecUtil.EncodeNullableFor{{ lang_name(param.type) }}(clientMessage, {% if param.type != "String" %}&{% endif %}{{ param_name(codec.name)}}.{{ param.name|capital }}) + {%- else -%} + Encode{{ lang_name(param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}) + {%- endif %} + {% endif %} {%- endmacro %} {% macro decode_var_sized(param) -%} - {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} - Decode{% if param.nullable %}Nullable{% endif %}ListMultiFrame{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}For{{ item_type(lang_name, param.type) }}(frameIterator) - {%- elif is_var_sized_entry_list(param.type) -%} - Decode{% if param.nullable %}Nullable{% endif %}EntryList(frameIterator, Decode{{ key_type(lang_name, param.type) }}, DecodeNullable{{ value_type(lang_name, param.type) }}) - {%- elif is_var_sized_map(param.type) -%} - Decode{% if param.nullable %}Nullable{% endif %}MapFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}(frameIterator) - {%- else -%} - {%- if param.nullable -%} - CodecUtil.DecodeNullableFor{{ lang_name(param.type) }}(frameIterator) - {%- else -%} - Decode{{ lang_name(param.type) }}(frameIterator) - {%- endif -%} - {%- endif -%} + {%- if is_var_sized_list(param.type) or is_var_sized_list_contains_nullable(param.type) -%} + Decode{% if param.nullable %}Nullable{% endif %}ListMultiFrame{% if is_var_sized_list_contains_nullable(param.type) %}ContainsNullable{% endif %}For{{ item_type(lang_name, param.type) }}(frameIterator) + {%- elif is_var_sized_entry_list(param.type) -%} + Decode{% if param.nullable %}Nullable{% endif %}EntryList(frameIterator, Decode{{ key_type(lang_name, param.type) }}, DecodeNullable{{ value_type(lang_name, param.type) }}) + {%- elif is_var_sized_map(param.type) -%} + Decode{% if param.nullable %}Nullable{% endif %}MapFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}(frameIterator) + {%- else -%} + {%- if param.nullable -%} + CodecUtil.DecodeNullableFor{{ lang_name(param.type) }}(frameIterator) + {%- else -%} + Decode{{ lang_name(param.type) }}(frameIterator) + {%- endif -%} + {%- endif -%} {%- endmacro %} {% macro insert_import_statements(stmts) %} import ( - "github.com/hazelcast/hazelcast-go-client/v4/internal/proto" - {% for stmt in stmts %} - {{ stmt }} - {% endfor %} + {% for stmt in stmts %} + {{ stmt }} + {% endfor %} ) {% endmacro %} {% set fix_sized_params = fixed_params(codec.params) %} @@ -56,125 +55,129 @@ import ( * See the License for the specific language governing permissions and * limitations under the License. */ + package codec {{ insert_import_statements( - get_import_path_holders( - codec.name, - fix_sized_params, - var_sized_params - ) + get_import_path_holders( + codec.name, + fix_sized_params, + var_sized_params + ) )}} {% if fix_sized_params|length > 0 %} const( {% for param in fix_sized_params %} - {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset = {% if loop.first %}0{% else %}{{ codec.name|capital }}Codec{{ loop.previtem.name|capital }}FieldOffset + proto.{{ loop.previtem.type|capital }}SizeInBytes{% endif %} + {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset = {% if loop.first %}0{% else %}{{ codec.name|capital }}Codec{{ loop.previtem.name|capital }}FieldOffset + proto.{{ loop.previtem.type|capital }}SizeInBytes{% endif %} - {% if loop.last %} - {{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize = {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset + proto.{{ param.type|capital }}SizeInBytes - {% endif %} + {% if loop.last %} + {{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize = {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset + proto.{{ param.type|capital }}SizeInBytes + {% endif %} {% endfor %} ) {% endif %} -/* -type {{ codec.name|lower }}Codec struct {} - -var {{ codec.name|capital }}Codec {{ codec.name|lower }}Codec -*/ - +{% if codec.name == "Address" %} +{% else %} func Encode{{ codec.name|capital }}(clientMessage *proto.ClientMessage, {{ param_name(codec.name) }} {{ lang_types_encode(codec.name) }}){ {% if should_add_begin_frame %} - clientMessage.AddFrame(proto.BeginFrame.Copy()) + clientMessage.AddFrame(proto.BeginFrame.Copy()) {% endif %} {% for param in fix_sized_params %} - {% if loop.last %} - initialFrame := proto.NewFrame(make([]byte,{{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize)) - {% endif %} + {% if loop.last %} + initialFrame := proto.NewFrame(make([]byte,{{ codec.name|capital }}Codec{{ param.name|capital }}InitialFrameSize)) + {% endif %} {% endfor %} {% for param in fix_sized_params %} - {% if escape_keyword(param.name).startswith('_') == true %} - {% set keyword = escape_keyword(param.name)[1:] %} - {% else %} - {% set keyword = escape_keyword(param.name) %} - {% endif %} - {% if param.type == "int" %} - {% set cast = "int32(" %} - {% elif param.type == "long" %} - {% set cast = "int64(" %} - {% else %} - {% set cast = "" %} - {% endif %} - FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset, {% if cast %}{{ cast }}{% endif %}{{ param_name(codec.name)}}.{{ keyword|capital }}(){% if cast %}){% endif %}) - {% if loop.last %} - {% if not should_add_begin_frame %} - initialFrame.flags |= BEGIN_DATA_STRUCTURE_FLAG - {% endif %} - clientMessage.AddFrame(initialFrame) - {% endif %} + {% if escape_keyword(param.name).startswith('_') == true %} + {% set keyword = escape_keyword(param.name)[1:] %} + {% else %} + {% set keyword = escape_keyword(param.name) %} + {% endif %} + {% if param.type == "int" %} + {% set cast = "int32(" %} + {% elif param.type == "long" %} + {% set cast = "int64(" %} + {% else %} + {% set cast = "" %} + {% endif %} + FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset, {% if cast %}{{ cast }}{% endif %}{{ param_name(codec.name)}}.{{ rename_field(codec.name, param) }}{% if cast %}){% endif %}) + {% if loop.last %} + {% if not should_add_begin_frame %} + initialFrame.flags |= BEGIN_DATA_STRUCTURE_FLAG + {% endif %} + clientMessage.AddFrame(initialFrame) + {% endif %} {% endfor %} {% for param in var_sized_params %} - {% if loop.first %} + {% if loop.first %} - {% endif %} - {% if lang_types_encode(param.type) == '!skip' %} - {% continue %} - {% endif %} - {{ encode_var_sized(param) }} + {% endif %} + {% if lang_types_encode(param.type) == '!skip' %} + {% continue %} + {% endif %} + {{ encode_var_sized(param) }} {% endfor %} - clientMessage.AddFrame(proto.EndFrame.Copy()) + clientMessage.AddFrame(proto.EndFrame.Copy()) } +{% endif %} func Decode{{ codec.name|capital }}(frameIterator *proto.ForwardFrameIterator) {{ lang_types_encode(codec.name) }} { - // begin frame + // begin frame {% if should_add_begin_frame %} - frameIterator.Next() + frameIterator.Next() {% endif %} {% for param in fix_sized_params %} - {% if loop.first %} - initialFrame := frameIterator.Next() - {% endif %} - {% if param in fix_sized_new_params %} - is{{ param.name|capital }}Exists := false - let {{ escape_keyword(param.name) }} = {% if param.type == 'boolean' %}false{% elif param.type == 'UUID' %}null{% else %}0{% endif %} - if (initialFrame.content.length >= {{ to_upper_snake_case(param.name) }}_OFFSET + BitsUtil.{{ param.type.upper() }}_SIZE_IN_BYTES) { - {{ escape_keyword(param.name) }} = FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ to_upper_snake_case(param.name) }}_OFFSET) - is{{ param.name|capital }}Exists = true - } - {% else %} - {{ escape_keyword(param.name) }} := FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset) - {% endif %} + {% if loop.first %} + initialFrame := frameIterator.Next() + {% endif %} + {% if param in fix_sized_new_params %} + let {{ escape_keyword(param.name) }} = {% if param.type == 'boolean' %}false{% elif param.type == 'UUID' %}null{% else %}0{% endif %} + if (initialFrame.content.length >= {{ to_upper_snake_case(param.name) }}_OFFSET + BitsUtil.{{ param.type.upper() }}_SIZE_IN_BYTES) { + {{ escape_keyword(param.name) }} = FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ to_upper_snake_case(param.name) }}_OFFSET) + } + {% else %} + {{ escape_keyword(param.name) }} := FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset) + {% endif %} {% endfor %} {% for param in var_sized_params %} - {% if loop.first %} + {% if loop.first %} - {% endif %} - {% if lang_types_decode(param.type) == '!skip' %} - {% continue %} - {% endif %} - {% if param in new_codec_params %} - is{{ param.name|capital }}Exists := false - var {{ escape_keyword(param.name) }} interface{} - if (!frameIterator.PeekNext().IsEndFrame()) { - {{ escape_keyword(param.name) }} = {{ decode_var_sized(param) }} - is{{ param.name|capital }}Exists = true - } - {% else %} - {{ escape_keyword(param.name) }} := {{ decode_var_sized(param) }} - {% endif %} + {% endif %} + {% if lang_types_decode(param.type) == '!skip' %} + {% continue %} + {% endif %} + {% if param in new_codec_params %} + var {{ escape_keyword(param.name) }} interface{} + if (!frameIterator.PeekNext().IsEndFrame()) { + {{ escape_keyword(param.name) }} = {{ decode_var_sized(param) }} + } + {% else %} + {{ escape_keyword(param.name) }} := {{ decode_var_sized(param) }} + {% endif %} {% endfor %} - CodecUtil.FastForwardToEndFrame(frameIterator) + CodecUtil.FastForwardToEndFrame(frameIterator) {% set ctor_params = [] %} {% for param in codec.params %} - {% if lang_types_decode(param.type) != '!skip' %} - {% do ctor_params.append(param) %} - {% endif %} + {% if lang_types_decode(param.type) != '!skip' %} + {% do ctor_params.append(param) %} + {% endif %} {% endfor %} - {% set encoded_codec_name = lang_types_encode(codec.name) %} - {% if encoded_codec_name.startswith("*") %} - {% set encoded_codec_name = encoded_codec_name[1:] %} - {% endif %} - return {{ encoded_codec_name.split('.')[0] }}.New{{ encoded_codec_name.split('.')[1] }}({% for param in ctor_params %}{% if param in new_codec_params %}is{{ param.name|capital }}Exists, {% endif %}{{ escape_keyword(param.name) }}{% if not loop.last %}, {% endif %}{% endfor %}) -} + {% set encoded_codec_name = lang_types_encode(codec.name) %} + {% if encoded_codec_name.startswith("*") %} + {% set encoded_codec_name = encoded_codec_name[1:] %} + {% endif %} + {% if codec.name == "Address"%} + return cluster.NewAddress(host, port) + {% else %} + return {% if "*" in lang_types_encode(codec.name) %}&{% endif %}{{ encoded_codec_name.split('.')[0] }}.{{ encoded_codec_name.split('.')[1] }}{% raw %}{{%endraw %} + + {% for param in ctor_params %} + {# {% if param in new_codec_params %}is{{ param.name|capital }}Exists, {% endif %} #} + {{ rename_field(codec.name, param) }}: {{ augment_enum(codec.name, param) }}, + {% endfor %} + } + {% endif %} +} diff --git a/go/verbatim/builtin.go b/go/verbatim/builtin.go index 880afb7d3..95c627bdb 100644 --- a/go/verbatim/builtin.go +++ b/go/verbatim/builtin.go @@ -620,6 +620,24 @@ func DecodeListMultiFrameForDataContainsNullable(frameIterator *proto.ForwardFra return result } +func DecodeListMultiFrameForDistributedObjectInfo(frameIterator *proto.ForwardFrameIterator) []types.DistributedObjectInfo { + var result []types.DistributedObjectInfo + frameIterator.Next() + for !CodecUtil.NextFrameIsDataStructureEndFrame(frameIterator) { + result = append(result, DecodeDistributedObjectInfo(frameIterator)) + } + frameIterator.Next() + return result +} + +func DecodeDistributedObjectInfo(frameIterator *proto.ForwardFrameIterator) types.DistributedObjectInfo { + frameIterator.Next() + serviceName := DecodeString(frameIterator) + name := DecodeString(frameIterator) + CodecUtil.FastForwardToEndFrame(frameIterator) + return types.DistributedObjectInfo{Name: name, ServiceName: serviceName} +} + func EncodeListData(message *proto.ClientMessage, entries []*iserialization.Data) { EncodeListMultiFrameForData(message, entries) } @@ -756,31 +774,6 @@ type DistributedObject interface { ServiceName() string } -type DistributedObjectInfo struct { - name string - serviceName string -} - -func (i *DistributedObjectInfo) Name() string { - return i.name -} - -func (i *DistributedObjectInfo) ServiceName() string { - return i.serviceName -} - -func (i *DistributedObjectInfo) GetName() string { - return i.name -} - -func (i *DistributedObjectInfo) GetServiceName() string { - return i.serviceName -} - -func NewDistributedObjectInfo(name string, serviceName string) DistributedObjectInfo { - return DistributedObjectInfo{name: name, serviceName: serviceName} -} - func NewMemberVersion(major, minor, patch byte) pubcluster.MemberVersion { return pubcluster.MemberVersion{Major: major, Minor: minor, Patch: patch} } diff --git a/go/verbatim/builtin_test.go b/go/verbatim/builtin_test.go index 4ac1964f5..351fcd0bd 100644 --- a/go/verbatim/builtin_test.go +++ b/go/verbatim/builtin_test.go @@ -1,12 +1,30 @@ +/* + * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License") + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + package codec import ( "encoding/binary" - "github.com/hazelcast/hazelcast-go-client/v4/internal/proto" "testing" - "github.com/hazelcast/hazelcast-go-client/v4/internal/core" + "github.com/hazelcast/hazelcast-go-client/types" + "github.com/stretchr/testify/assert" + + "github.com/hazelcast/hazelcast-go-client/internal/proto" ) func TestCodecUtil_FastForwardToEndFrame(t *testing.T) { @@ -25,7 +43,6 @@ func TestCodecUtil_FastForwardToEndFrame(t *testing.T) { //then assert.False(t, iterator.HasNext()) - println(message.GetCorrelationID()) } func TestCodecUtil_EncodeNullable(t *testing.T) { @@ -34,19 +51,19 @@ func TestCodecUtil_EncodeNullable(t *testing.T) { message := proto.NewClientMessage(frame1) //when - CodecUtil.EncodeNullable(message, "encode-value-1", StringCodec.Encode) + CodecUtil.EncodeNullable(message, "encode-value-1", EncodeString) //then iterator := message.FrameIterator() assert.Equal(t, string(iterator.Next().Content), "value-0") assert.Equal(t, string(iterator.Next().Content), "encode-value-1") - assert.Equal(t, string(message.EndFrame.Content), "encode-value-1") + assert.Equal(t, string(message.Frames[len(message.Frames)-1].Content), "encode-value-1") } func TestCodecUtil_NextFrameIsDataStructureEndFrame(t *testing.T) { //given byteValue := []byte("value-0") - flags := int32(proto.EndDataStructureFlag) + flags := uint16(proto.EndDataStructureFlag) frame := proto.NewFrameWith(byteValue, flags) message := proto.NewClientMessage(frame) //when @@ -93,7 +110,7 @@ func TestByteArrayCodec_Encode(t *testing.T) { message := proto.NewClientMessageForEncode() //when - ByteArrayCodec.Encode(message, value) + EncodeByteArray(message, value) //then iterator := message.FrameIterator() @@ -106,7 +123,7 @@ func TestByteArrayCodec_Decode(t *testing.T) { message := proto.NewClientMessage(proto.NewFrame(value)) //when - decode := ByteArrayCodec.Decode(message.FrameIterator()) + decode := DecodeByteArray(message.FrameIterator()) //then assert.Equal(t, string(decode), "value-1") @@ -118,7 +135,7 @@ func TestCodecUtil_EncodeNullable_If_Value_Is_Null_Add_Null_Frame_To_Message(t * message := proto.NewClientMessage(frame1) //when - CodecUtil.EncodeNullable(message, nil, StringCodec.Encode) + CodecUtil.EncodeNullable(message, nil, EncodeString) //then iterator := message.FrameIterator() @@ -131,7 +148,7 @@ func TestDataCodec_EncodeNullable_When_Data_Is_Nil(t *testing.T) { message := proto.NewClientMessageForEncode() //when - DataCodec.EncodeNullable(message, nil) + EncodeNullableData(message, nil) //then iterator := message.FrameIterator() @@ -146,7 +163,7 @@ func TestDataCodec_Decode(t *testing.T) { frameIterator := message.FrameIterator() //when - decode := DataCodec.Decode(frameIterator) + decode := DecodeNullableData(frameIterator) //then assert.Equal(t, decode.ToByteArray(), bytes) @@ -159,7 +176,7 @@ func TestDataCodec_Decode_When_Data_Is_Nil(t *testing.T) { frameIterator := message.FrameIterator() //when - decode := DataCodec.DecodeNullable(frameIterator) + decode := DecodeNullableData(frameIterator) //then assert.Nil(t, decode) @@ -174,7 +191,7 @@ func TestEntryListCodec_Encode(t *testing.T) { pairs = append(pairs, proto.NewPair("key", "value")) //when - EntryListCodec.Encode(message, pairs, StringCodec.Encode, StringCodec.Encode) + EncodeEntryList(message, pairs, EncodeString, EncodeString) //then frameIterator := message.FrameIterator() @@ -200,7 +217,7 @@ func TestEntryListCodec_Encode_When_Entries_Is_Empty(t *testing.T) { pairs := make([]proto.Pair, 0) //when - EntryListCodec.Encode(message, pairs, StringCodec.Encode, StringCodec.Encode) + EncodeEntryList(message, pairs, EncodeString, EncodeString) //then frameIterator := message.FrameIterator() @@ -224,7 +241,7 @@ func TestEntryListCodec_EncodeNullable(t *testing.T) { pairs = append(pairs, proto.NewPair("key", "value")) //when - EntryListCodec.EncodeNullable(message, pairs, StringCodec.Encode, StringCodec.Encode) + EncodeNullableEntryList(message, pairs, EncodeString, EncodeString) //then frameIterator := message.FrameIterator() @@ -248,7 +265,7 @@ func TestEntryListCodec_EncodeNullable_When_Entries_Is_Empty(t *testing.T) { pairs := make([]proto.Pair, 0) //when - EntryListCodec.EncodeNullable(message, pairs, StringCodec.Encode, StringCodec.Encode) + EncodeNullableEntryList(message, pairs, EncodeString, EncodeString) //then frameIterator := message.FrameIterator() @@ -262,7 +279,7 @@ func TestEntryListCodec_DecodeNullable(t *testing.T) { iterator := message.FrameIterator() //when - results := EntryListCodec.DecodeNullable(iterator, DataCodec.Decode, DataCodec.Decode) + results := DecodeNullableEntryList(iterator, DecodeData, DecodeData) //then assert.Nil(t, results) @@ -274,7 +291,7 @@ func TestEntryListCodec_DecodeNullable_When_Next_Frame_Is_Null_Frame(t *testing. iterator := message.FrameIterator() //when - results := EntryListCodec.DecodeNullable(iterator, DataCodec.Decode, DataCodec.Decode) + results := DecodeNullableEntryList(iterator, DecodeData, DecodeData) //then assert.Empty(t, results) @@ -387,15 +404,15 @@ func TestFixSizedTypesCodec_EncodeUUID(t *testing.T) { //given buffer := make([]byte, proto.UUIDSizeInBytes) offset := int32(0) - uuid := core.NewUUID() + uuid := types.NewUUID() //when FixSizedTypesCodec.EncodeUUID(buffer, offset, uuid) //then assert.Equal(t, FixSizedTypesCodec.DecodeBoolean(buffer, offset), false) - assert.Equal(t, FixSizedTypesCodec.DecodeLong(buffer, offset+proto.BooleanSizeInBytes), int64(uuid.GetMostSignificantBits())) - assert.Equal(t, FixSizedTypesCodec.DecodeLong(buffer, offset+proto.BooleanSizeInBytes+proto.LongSizeInBytes), int64(uuid.GetLeastSignificantBits())) + assert.Equal(t, FixSizedTypesCodec.DecodeLong(buffer, offset+proto.BooleanSizeInBytes), int64(uuid.MostSignificantBits())) + assert.Equal(t, FixSizedTypesCodec.DecodeLong(buffer, offset+proto.BooleanSizeInBytes+proto.LongSizeInBytes), int64(uuid.LeastSignificantBits())) } func TestFixSizedTypesCodec_EncodeUUID_When_UUID_Is_Nil(t *testing.T) { @@ -404,7 +421,7 @@ func TestFixSizedTypesCodec_EncodeUUID_When_UUID_Is_Nil(t *testing.T) { offset := int32(0) //when - FixSizedTypesCodec.EncodeUUID(buffer, offset, nil) + FixSizedTypesCodec.EncodeUUID(buffer, offset, types.UUID{}) //then assert.Equal(t, FixSizedTypesCodec.DecodeBoolean(buffer, offset), true) @@ -414,7 +431,7 @@ func TestFixSizedTypesCodec_DecodeUUID(t *testing.T) { //given buffer := make([]byte, proto.UUIDSizeInBytes) offset := int32(0) - uuid := core.NewUUID() + uuid := types.NewUUID() FixSizedTypesCodec.EncodeUUID(buffer, offset, uuid) //when @@ -422,46 +439,47 @@ func TestFixSizedTypesCodec_DecodeUUID(t *testing.T) { //then assert.Equal(t, FixSizedTypesCodec.DecodeBoolean(buffer, offset), false) - assert.Equal(t, uuid.ToString(), decodeUUID.ToString()) - assert.Equal(t, uuid.GetMostSignificantBits(), decodeUUID.GetMostSignificantBits()) - assert.Equal(t, uuid.GetLeastSignificantBits(), decodeUUID.GetLeastSignificantBits()) + assert.Equal(t, uuid, decodeUUID) + assert.Equal(t, uuid.String(), decodeUUID.String()) + assert.Equal(t, uuid.MostSignificantBits(), decodeUUID.MostSignificantBits()) + assert.Equal(t, uuid.LeastSignificantBits(), decodeUUID.LeastSignificantBits()) } func TestEntryListUUIDLongCodec_Encode(t *testing.T) { // given message := proto.NewClientMessageForEncode() - key := core.NewUUID() + key := types.NewUUID() value := int64(100) pairs := make([]proto.Pair, 0) pairs = append(pairs, proto.NewPair(key, value)) - EntryListUUIDLongCodec.Encode(message, pairs) + EncodeEntryListUUIDLong(message, pairs) // when - pairs = EntryListUUIDLongCodec.Decode(message.FrameIterator()) + pairs = DecodeEntryListUUIDLong(message.FrameIterator()) // then frame := pairs[0] - assert.Equal(t, frame.Key().(core.UUID).ToString(), key.ToString()) + assert.Equal(t, frame.Key().(types.UUID).String(), key.String()) assert.Equal(t, frame.Value().(int64), value) } func TestListUUIDCodec_Encode(t *testing.T) { // given message := proto.NewClientMessageForEncode() - entries := make([]core.UUID, 0) - value1 := core.NewUUID() - value2 := core.NewUUID() + entries := make([]types.UUID, 0) + value1 := types.NewUUID() + value2 := types.NewUUID() entries = append(entries, value1, value2) // when - ListUUIDCodec.Encode(message, entries) + EncodeListUUID(message, entries) // then frame := message.FrameIterator().Next() decodeUUID1 := FixSizedTypesCodec.DecodeUUID(frame.Content, 0) - assert.Equal(t, value1.ToString(), decodeUUID1.ToString()) + assert.Equal(t, value1.String(), decodeUUID1.String()) decodeUUID2 := FixSizedTypesCodec.DecodeUUID(frame.Content, 17) - assert.Equal(t, value2.ToString(), decodeUUID2.ToString()) + assert.Equal(t, value2.String(), decodeUUID2.String()) } func TestListIntegerCodec_Encode(t *testing.T) { @@ -471,7 +489,7 @@ func TestListIntegerCodec_Encode(t *testing.T) { entries = append(entries, 1, 2, 3) // when - ListIntegerCodec.Encode(clientMessage, entries) + EncodeListInteger(clientMessage, entries) // then frame := clientMessage.FrameIterator().Next() @@ -485,10 +503,10 @@ func TestListIntegerCodec_Decode(t *testing.T) { clientMessage := proto.NewClientMessageForEncode() entries := make([]int32, 0) entries = append(entries, 1, 2, 3) - ListIntegerCodec.Encode(clientMessage, entries) + EncodeListInteger(clientMessage, entries) // when - decodeEntries := ListIntegerCodec.Decode(clientMessage.FrameIterator()) + decodeEntries := DecodeListInteger(clientMessage.FrameIterator()) // then assert.Equal(t, decodeEntries[0], int32(1)) @@ -503,7 +521,7 @@ func TestListLongCodec_Encode(t *testing.T) { entries = append(entries, 1, 2, 3) // when - ListLongCodec.Encode(message, entries) + EncodeListLong(message, entries) // then frame := message.FrameIterator().Next() @@ -517,10 +535,10 @@ func TestListLongCodec_Decode(t *testing.T) { message := proto.NewClientMessageForEncode() entries := make([]int64, 0) entries = append(entries, 1, 2, 3) - ListLongCodec.Encode(message, entries) + EncodeListLong(message, entries) // when - result := ListLongCodec.Decode(message.FrameIterator()) + result := DecodeListLong(message.FrameIterator()) // then assert.Equal(t, result, entries) @@ -529,7 +547,7 @@ func TestListLongCodec_Decode(t *testing.T) { func TestEntryListUUIDListIntegerCodec_Encode(t *testing.T) { // given clientMessage := proto.NewClientMessageForEncode() - key := core.NewUUID() + key := types.NewUUID() value := make([]int32, 0) value = append(value, 1, 2, 3) pair := proto.NewPair(key, value) @@ -537,7 +555,7 @@ func TestEntryListUUIDListIntegerCodec_Encode(t *testing.T) { entries = append(entries, pair) // when - EntryListUUIDListIntegerCodec.Encode(clientMessage, entries) + EncodeEntryListUUIDListInteger(clientMessage, entries) // then iterator := clientMessage.FrameIterator() @@ -548,26 +566,26 @@ func TestEntryListUUIDListIntegerCodec_Encode(t *testing.T) { assert.Equal(t, FixSizedTypesCodec.DecodeInt(integerValues.Content, 8), int32(3)) assert.Equal(t, iterator.Next().IsEndFrame(), true) uuid := FixSizedTypesCodec.DecodeUUID(iterator.Next().Content, 0) - assert.Equal(t, uuid.ToString(), key.ToString()) + assert.Equal(t, uuid.String(), key.String()) } func TestEntryListUUIDListIntegerCodec_Decode(t *testing.T) { // given clientMessage := proto.NewClientMessageForEncode() - key := core.NewUUID() + key := types.NewUUID() value := make([]int32, 0) value = append(value, 1, 2, 3) pair := proto.NewPair(key, value) entries := make([]proto.Pair, 0) entries = append(entries, pair) - EntryListUUIDListIntegerCodec.Encode(clientMessage, entries) + EncodeEntryListUUIDListInteger(clientMessage, entries) // when - result := EntryListUUIDListIntegerCodec.Decode(clientMessage.FrameIterator()) + result := DecodeEntryListUUIDListInteger(clientMessage.FrameIterator()) // then assert.Equal(t, len(result), 1) - assert.Equal(t, result[0].Key().([]core.UUID)[0].ToString(), key.ToString()) + assert.Equal(t, result[0].Key().([]types.UUID)[0].String(), key.String()) assert.EqualValues(t, result[0].Value().([]int32), value) } @@ -578,7 +596,7 @@ func TestLongArrayCodec_Encode(t *testing.T) { entries = append(entries, 1, 2, 3) // when - LongArrayCodec.Encode(clientMessage, entries) + EncodeLongArray(clientMessage, entries) // then frame := clientMessage.FrameIterator().Next() @@ -592,10 +610,10 @@ func TestLongArrayCodec_Decode(t *testing.T) { clientMessage := proto.NewClientMessageForEncode() entries := make([]int64, 0) entries = append(entries, 1, 2, 3) - LongArrayCodec.Encode(clientMessage, entries) + EncodeLongArray(clientMessage, entries) // when - result := LongArrayCodec.Decode(clientMessage.FrameIterator()) + result := DecodeLongArray(clientMessage.FrameIterator()) // then assert.Equal(t, result[0], int64(1)) @@ -611,9 +629,9 @@ func TestStringCodec_Encode(t *testing.T) { clientMessage := proto.NewClientMessage(frame) //when - StringCodec.Encode(clientMessage, value) + EncodeString(clientMessage, value) //then - content := clientMessage.EndFrame.Content + content := clientMessage.Frames[len(clientMessage.Frames)-1].Content assert.Equal(t, value, string(content)) } diff --git a/util.py b/util.py index 121af92e2..00e1c9cdf 100644 --- a/util.py +++ b/util.py @@ -19,7 +19,8 @@ from cpp import cpp_ignore_service_list, cpp_types_decode, cpp_types_encode, get_size, is_trivial from cs import cs_escape_keyword, cs_ignore_service_list, cs_types_decode, cs_types_encode from java import java_types_decode, java_types_encode -from go import go_types_encode, go_types_decode, go_ignore_service_list, go_get_import_statements, go_escape_keyword +from go import go_types_encode, go_types_decode, go_ignore_service_list, \ + go_get_import_statements, go_escape_keyword, go_augment_enum, go_rename_field from md import internal_services from py import ( py_escape_keyword, @@ -566,6 +567,12 @@ def inner(*names): SupportedLanguages.GO: go_get_import_statements, # exposed as: get_import_path_holders SupportedLanguages.MD: lambda x: x, }, + "augment_enum": { + SupportedLanguages.GO: go_augment_enum, + }, + "rename_field": { + SupportedLanguages.GO: go_rename_field, + } "custom_type_name": { SupportedLanguages.JAVA: lambda x: x, SupportedLanguages.CS: lambda x: x, @@ -638,5 +645,7 @@ def create_environment(lang, namespace): env.globals["get_import_path_holders"] = language_specific_funcs["get_import_path_holders"][ lang ] + env.globals["augment_enum"] = language_specific_funcs["augment_enum"].get(lang) + env.globals["rename_field"] = language_specific_funcs["rename_field"].get(lang) return env From 6988873cef12d77c6bac21db6d2ea0c3df597c56 Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Wed, 22 Sep 2021 06:20:42 +0300 Subject: [PATCH 23/41] updates --- util.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/util.py b/util.py index 00e1c9cdf..66c917dee 100644 --- a/util.py +++ b/util.py @@ -1,9 +1,7 @@ import hashlib import json -import os import re import fnmatch -from enum import Enum import os from os import listdir, makedirs from os.path import dirname, isfile, join, realpath @@ -572,7 +570,7 @@ def inner(*names): }, "rename_field": { SupportedLanguages.GO: go_rename_field, - } + }, "custom_type_name": { SupportedLanguages.JAVA: lambda x: x, SupportedLanguages.CS: lambda x: x, From f44bcf317dd9b2fe9ac52f8f1a375b67a7e6848f Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Wed, 22 Dec 2021 14:45:35 +0300 Subject: [PATCH 24/41] updates --- go/__init__.py | 31 ++++++++++++++++++++++++------- util.py | 1 + 2 files changed, 25 insertions(+), 7 deletions(-) diff --git a/go/__init__.py b/go/__init__.py index c7cd889f3..68ba09be0 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -2,7 +2,7 @@ "chan", "else", "goto", "package", "switch", "const", "fallthrough", "if", "range", "type", "continue", "for", "import", "return", "var"} -go_ignore_service_list = {"MC", "Sql", "ExecutorService", "TransactionalMap", "TransactionalMultiMap", +go_ignore_service_list = {"MC", "ExecutorService", "TransactionalMap", "TransactionalMultiMap", "TransactionalSet", "TransactionalList", "TransactionalQueue", "Cache", "XATransaction", "Transaction", "ContinuousQuery", "DurableExecutor", "CardinalityEstimator", "ScheduledExecutor", "DynamicConfig", "CPSubsystem"} @@ -132,6 +132,16 @@ class PathHolders: StackTraceElementCodec = InternalImportPathHolder("StackTraceElementCodec", None, is_custom_codec=True) StringCodec = InternalImportPathHolder("StringCodec", None, is_builtin_codec=True) UUID = ImportPathHolder("UUID", "/types") + ListSqlColumnMetadata = ImportPathHolder("ListSqlColumnMetadata", "/sql") + ListSqlColumnMetadataCodec = ImportPathHolder("ListSqlColumnMetadataCodec", "/sql") + SqlError = InternalImportPathHolder("SqlError", "sql") + SqlErrorCodec = InternalImportPathHolder("SqlErrorCodec", "sql") + SqlQueryId = InternalImportPathHolder("SqlQueryID", "sql") + SqlQueryIdCodec = InternalImportPathHolder("SqlQueryIDCodec", "sql") + SqlPage = InternalImportPathHolder("SqlPage", "sql") + SqlPageCodec = InternalImportPathHolder("SqlPageCodec", "sql") + SqlColumnMetadata = ImportPathHolder("SqlColumnMetadata", "/sql") + SqlColumnMetadataCodec = ImportPathHolder("SqlColumnMetadataCodec", "/sql") import_paths = { @@ -178,6 +188,12 @@ class PathHolders: "byteArray": [PathHolders.ByteArrayCodec], "longArray": [PathHolders.LongArrayCodec], 'List_MemberInfo': [PathHolders.MemberInfo, PathHolders.ListMultiFrameCodec, PathHolders.MemberInfoCodec], + "List_SqlColumnMetadata": [PathHolders.ListSqlColumnMetadata, PathHolders.SqlColumnMetadataCodec], + "SqlError": [PathHolders.SqlError, PathHolders.SqlErrorCodec], + "SqlQueryId": [PathHolders.SqlQueryId, PathHolders.SqlQueryIdCodec], + "SqlPage": [PathHolders.SqlPage, PathHolders.SqlPageCodec], + "SqlColumnMetadata": [PathHolders.SqlColumnMetadata, PathHolders.SqlColumnMetadataCodec], + } _go_types_common = { @@ -228,6 +244,13 @@ class PathHolders: "int": "int32", "long": "int64", "longArray": "[]int64", + "ListCN_Data": "[]*iserialization.Data", + "List_ListCN_Data": "[]*iserialization.Data", + "List_SqlColumnMetadata": "[]sql.ColumnMetadata", + "SqlError": "isql.Error", + "SqlQueryId": "isql.QueryID", + "SqlPage": "isql.Page", + "SqlColumnMetadata": "sql.ColumnMetadata", } _go_types_encode = { @@ -248,7 +271,6 @@ class PathHolders: "EntryList_UUID_List_Integer": "[]proto.Pair", "EntryList_UUID_Long": "[]proto.Pair", "EntryList_UUID_UUID": "[]proto.Pair", - # "ListCN_Data": "[]*iserialization.Data", "List_AttributeConfig": "NA", # "List_CacheEventData": "NA", # "List_CacheSimpleEntryListenerConfig": "NA", @@ -257,7 +279,6 @@ class PathHolders: "List_DistributedObjectInfo": "[]types.DistributedObjectInfo", "List_IndexConfig": "[]types.IndexConfig", "List_Integer": "[]int32", - # "List_ListCN_Data": "NA", "List_List_Data": "[]*iserialization.Data", # "List_ListenerConfigHolder": "NA", "List_Long": "[]int64", @@ -266,7 +287,6 @@ class PathHolders: # "List_QueryCacheConfigHolder": "NA", # "List_QueryCacheEventData": "NA", # "List_ScheduledTaskHandler": "NA", - # "List_SqlColumnMetadata": "NA", "List_StackTraceElement": "[]ihzerrors.StackTraceElement", "List_String": "[]string", "List_UUID": "[]types.UUID", @@ -279,9 +299,6 @@ class PathHolders: "PagingPredicateHolder": "NA", # "QueryCacheEventData": "NA", # "ScheduledTaskHandler": "NA", - # "SqlColumnMetadata": "NA", - # "SqlError": "NA", - # "SqlQueryId": "NA", # "Xid": "NA", } diff --git a/util.py b/util.py index 66c917dee..f05b4cee4 100644 --- a/util.py +++ b/util.py @@ -577,6 +577,7 @@ def inner(*names): SupportedLanguages.CPP: lambda x: x, SupportedLanguages.TS: lambda x: x, SupportedLanguages.PY: py_custom_type_name, + SupportedLanguages.GO: lambda x: x, SupportedLanguages.MD: lambda x: x, } } From cda20d2fc14e9044fb8a79f07c4ea33e97ce63f1 Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Tue, 15 Feb 2022 05:51:54 +0300 Subject: [PATCH 25/41] initial Go client extensibility --- generator.py | 27 +- go/__init__.py | 384 +----------------- ...codec-template.go.j2 => codec-template.j2} | 20 +- util.py | 25 +- 4 files changed, 36 insertions(+), 420 deletions(-) rename go/{codec-template.go.j2 => codec-template.j2} (88%) diff --git a/generator.py b/generator.py index 918e95648..93081d85f 100755 --- a/generator.py +++ b/generator.py @@ -2,13 +2,14 @@ import argparse import time -from os.path import abspath, dirname, exists, join, realpath +from os.path import abspath, exists from jinja2 import TemplateNotFound from binary.util import binary_output_directories, test_output_directories from binary_generator import get_binary_templates, save_binary_files, save_test_files from util import * +from go import GoGenerator start = time.time() @@ -119,7 +120,21 @@ "should be performed. These checks are done by default.", ) +parser.add_argument( + "-s", + "--service", + action="append", + help="Specify the service to include. Can be used more than once to add more services.", +) + +parser.add_argument( + "--go-config", + help="(Go only) Specifies the Go generator configuration file. Implies '-l go'", +) + args = parser.parse_args() +if args.go_config: + args.lang = "go" lang = SupportedLanguages[args.lang.upper()] @@ -156,13 +171,19 @@ print("Hazelcast Client Binary Protocol version", protocol_versions[-1]) +copy_verbatim_files(codec_output_dir, lang.value) + +if lang == SupportedLanguages.GO: + gen = GoGenerator(protocol_defs, codec_output_dir, args) + gen.generate() + exit(0) + env = create_environment(lang, args.namespace) -copy_verbatim_files(codec_output_dir, lang.value, env) if lang != SupportedLanguages.MD: codec_template = env.get_template("codec-template.%s.j2" % lang.value) - generate_codecs(protocol_defs, codec_template, codec_output_dir, lang, env) + generate_codecs(protocol_defs, codec_template, codec_output_dir, lang, env, args) print("Generated codecs are at '%s'" % abspath(codec_output_dir)) if custom_protocol_defs: diff --git a/go/__init__.py b/go/__init__.py index 68ba09be0..d3f0ccae9 100644 --- a/go/__init__.py +++ b/go/__init__.py @@ -1,383 +1 @@ -go_reserved_keywords = {"break", "default", "func", "interface", "select", "case", "defer", "go", "map", "struct", - "chan", "else", "goto", "package", "switch", "const", "fallthrough", "if", "range", "type", - "continue", "for", "import", "return", "var"} - -go_ignore_service_list = {"MC", "ExecutorService", "TransactionalMap", "TransactionalMultiMap", - "TransactionalSet", "TransactionalList", "TransactionalQueue", "Cache", "XATransaction", - "Transaction", "ContinuousQuery", "DurableExecutor", - "CardinalityEstimator", "ScheduledExecutor", "DynamicConfig", "CPSubsystem"} - - -def go_escape_keyword(value): - if value not in go_reserved_keywords: - return value - return "_%s" % value - - -def go_types_encode(key): - try: - go_type = _go_types_encode[key] - except KeyError: - try: - go_type = _go_types_common[key] - except KeyError: - go_type = "NA" - if go_type == "NA": - raise NotImplementedError("Missing type mapping for '" + key + "'") - return go_type - - -def go_types_decode(key): - try: - go_type = _go_types_decode[key] - except KeyError: - try: - go_type = _go_types_common[key] - except KeyError: - go_type = "NA" - if go_type == "NA": - raise NotImplementedError("Missing type for '" + key + "'") - return go_type - - -def go_get_import_statements(*args): - import_statements = set() - for arg in args: - params = [arg] if isinstance(arg, str) else arg - for param in params: - type = param["type"] if isinstance(param, dict) else param - for path_holder in import_paths.get(type, []): - if path_holder.name.endswith("Codec"): - continue - path = path_holder.import_statement - if path is not None: - import_statements.add(path) - import_statements.add('"github.com/hazelcast/hazelcast-go-client/internal/proto"') - if args[0] == "SimpleEntryView": - import_statements.remove('iserialization"github.com/hazelcast/hazelcast-go-client/internal/serialization"') - return sorted(import_statements) - - -class ImportPathHolder: - def __init__(self, name, path, is_builtin_codec=False, is_custom_codec=False): - self.name = name - self.path = path - - @property - def import_statement(self): - if not self.path: - return "" - return '''"github.com/hazelcast/hazelcast-go-client%s"''' % self.path - - -class InternalImportPathHolder: - def __init__(self, name, path, alias="", is_builtin_codec=False, is_custom_codec=False): - self.name = name - self.path = path - self.alias = alias - - @property - def import_statement(self): - if self.path is None: - return "" - alias = "%s " % self.alias if self.alias else "" - return '''%s"github.com/hazelcast/hazelcast-go-client/internal%s"''' % (self.alias, self.path) - - -class PathHolders: - Address = ImportPathHolder("Address", "/cluster") - AddressCodec = InternalImportPathHolder("AddressCodec", None, is_custom_codec=True) - AnchorDataListHolder = InternalImportPathHolder("AnchorDataListHolder", "") - AnchorDataListHolderCodec = InternalImportPathHolder("AnchorDataListHolderCodec", "", is_custom_codec=True) - BitmapIndexOptions = ImportPathHolder("BitmapIndexOptions", "/types") - BitmapIndexOptionsCodec = InternalImportPathHolder("BitmapIndexOptionsCodec", None, is_custom_codec=True) - ByteArrayCodec = InternalImportPathHolder("ByteArrayCodec", "", is_builtin_codec=True) - CodecUtilCodec = InternalImportPathHolder("CodecUtil", "", is_builtin_codec=True) - Data = InternalImportPathHolder('Data', '/serialization', 'iserialization') - DataCodec = InternalImportPathHolder("DataCodec", "", is_builtin_codec=True) - DistributedObjectInfo = ImportPathHolder("DistributedObjectInfo", "/types") - DistributedObjectInfoCodec = InternalImportPathHolder("DistributedObjectInfoCodec", None, is_custom_codec=True) - EndpointQualifier = ImportPathHolder("EndpointQualifier", "/cluster") - EndpointQualifierCodec = InternalImportPathHolder("EndpointQualifierCodec", None, is_custom_codec=True) - EntryListCodec = InternalImportPathHolder("EntryListCodec", "", is_builtin_codec=True) - EntryListIntegerIntegerCodec = InternalImportPathHolder("EntryListIntegerIntegerCodec", "", is_builtin_codec=True) - EntryListIntegerLongCodec = InternalImportPathHolder("EntryListIntegerLongCodec", "", is_builtin_codec=True) - EntryListIntegerUUIDCodec = InternalImportPathHolder("EntryListIntegerUUIDCodec", "", is_builtin_codec=True) - EntryListLongByteArrayCodec = InternalImportPathHolder("EntryListLongByteArrayCodec", "", is_builtin_codec=True) - EntryListUUIDListIntegerCodec = InternalImportPathHolder("EntryListUUIDListIntegerCodec", "", is_builtin_codec=True) - EntryListUUIDLongCodec = InternalImportPathHolder("EntryListUUIDLongCodec", "", is_builtin_codec=True) - EntryListUUIDUUIDCodec = InternalImportPathHolder("EntryListUUIDUUIDCodec", "", is_builtin_codec=True) - ErrorHolder = InternalImportPathHolder("ErrorHolder", "/proto") - ErrorHolderCodec = InternalImportPathHolder("ErrorHolderCodec", "", is_custom_codec=True) - IndexConfig = ImportPathHolder("IndexConfig", "/types") - IndexConfigCodec = InternalImportPathHolder("IndexConfigCodec", "", is_custom_codec=True) - ListDataCodec = InternalImportPathHolder("ListDataCodec", "", is_builtin_codec=True) - ListIntegerCodec = InternalImportPathHolder("ListIntegerCodec", "", is_builtin_codec=True) - ListLongCodec = InternalImportPathHolder("ListLongCodec", "", is_builtin_codec=True) - ListMultiFrameCodec = InternalImportPathHolder("ListMultiFrameCodec", None, is_builtin_codec=True) - ListUUIDCodec = InternalImportPathHolder("ListUUIDCodec", "", is_builtin_codec=True) - LongArrayCodec = InternalImportPathHolder("LongArrayCodec", "", is_builtin_codec=True) - MapCodec = InternalImportPathHolder("MapCodec", None, is_builtin_codec=True) - MemberInfo = ImportPathHolder("MemberInfo", "/cluster") - MemberInfoCodec = InternalImportPathHolder("MemberInfoCodec", "", is_custom_codec=True) - MemberVersion = ImportPathHolder("MemberVersion", "/cluster") - MemberVersionCodec = InternalImportPathHolder("MemberVersionCodec", None, is_custom_codec=True) - PagingPredicateHolder = InternalImportPathHolder("PagingPredicateHolder", "") - PagingPredicateHolderCodec = InternalImportPathHolder("PagingPredicateHolderCodec", "", is_custom_codec=True) - RaftGroupId = InternalImportPathHolder("RaftGroupId", "") - RaftGroupIdCodec = InternalImportPathHolder("RaftGroupIdCodec", "", is_custom_codec=True) - SimpleEntryView = ImportPathHolder("SimpleEntryView", "/types") - SimpleEntryViewCodec = InternalImportPathHolder("SimpleEntryViewCodec", None, is_custom_codec=True) - StackTraceElement = InternalImportPathHolder("StackTraceElement", "/hzerrors", alias="ihzerrors") - StackTraceElementCodec = InternalImportPathHolder("StackTraceElementCodec", None, is_custom_codec=True) - StringCodec = InternalImportPathHolder("StringCodec", None, is_builtin_codec=True) - UUID = ImportPathHolder("UUID", "/types") - ListSqlColumnMetadata = ImportPathHolder("ListSqlColumnMetadata", "/sql") - ListSqlColumnMetadataCodec = ImportPathHolder("ListSqlColumnMetadataCodec", "/sql") - SqlError = InternalImportPathHolder("SqlError", "sql") - SqlErrorCodec = InternalImportPathHolder("SqlErrorCodec", "sql") - SqlQueryId = InternalImportPathHolder("SqlQueryID", "sql") - SqlQueryIdCodec = InternalImportPathHolder("SqlQueryIDCodec", "sql") - SqlPage = InternalImportPathHolder("SqlPage", "sql") - SqlPageCodec = InternalImportPathHolder("SqlPageCodec", "sql") - SqlColumnMetadata = ImportPathHolder("SqlColumnMetadata", "/sql") - SqlColumnMetadataCodec = ImportPathHolder("SqlColumnMetadataCodec", "/sql") - - -import_paths = { - "Address": [PathHolders.Address, PathHolders.AddressCodec], - "AnchorDataListHolder": [PathHolders.AnchorDataListHolder, PathHolders.AnchorDataListHolderCodec], - "BitmapIndexOptions": [PathHolders.BitmapIndexOptions, PathHolders.BitmapIndexOptionsCodec], - "CodecUtil": PathHolders.CodecUtilCodec, - "Data": [PathHolders.Data, PathHolders.DataCodec], - "DistributedObjectInfo": [PathHolders.DistributedObjectInfo, PathHolders.DistributedObjectInfoCodec], - "EndpointQualifier": [PathHolders.EndpointQualifier], - "EntryList_Data_Data": [PathHolders.EntryListCodec, PathHolders.DataCodec], - "EntryList_Data_List_Data": [PathHolders.EntryListCodec, PathHolders.DataCodec, PathHolders.ListDataCodec], - "EntryList_Integer_Integer": [PathHolders.EntryListIntegerIntegerCodec], - "EntryList_Integer_Long": [PathHolders.EntryListIntegerLongCodec], - "EntryList_Integer_UUID": [PathHolders.EntryListIntegerUUIDCodec], - "EntryList_Long_byteArray": [PathHolders.EntryListLongByteArrayCodec], - "EntryList_String_EntryList_Integer_Long": [PathHolders.EntryListCodec, PathHolders.StringCodec, PathHolders.EntryListIntegerLongCodec], - "EntryList_String_String": [PathHolders.EntryListCodec, PathHolders.StringCodec], - "EntryList_String_byteArray": [PathHolders.EntryListCodec, PathHolders.StringCodec, PathHolders.ByteArrayCodec], - "EntryList_UUID_List_Integer": [PathHolders.EntryListUUIDListIntegerCodec], - "EntryList_UUID_Long": [PathHolders.EntryListUUIDLongCodec], - "EntryList_UUID_UUID": [PathHolders.EntryListUUIDUUIDCodec], - "ErrorHolder": [PathHolders.ErrorHolder, PathHolders.ErrorHolderCodec], - "IndexConfig": [PathHolders.IndexConfig, PathHolders.IndexConfigCodec], - "ListCN_Data": [PathHolders.ListMultiFrameCodec, PathHolders.DataCodec], - "ListIndexConfig": [PathHolders.IndexConfigCodec, PathHolders.ListMultiFrameCodec], - "List_Data": [PathHolders.Data, PathHolders.ListMultiFrameCodec, PathHolders.DataCodec], - "List_DistributedObjectInfo": [PathHolders.ListMultiFrameCodec, PathHolders.DistributedObjectInfo, PathHolders.DistributedObjectInfoCodec], - "List_Integer": [PathHolders.ListIntegerCodec], - "List_Long": [PathHolders.ListLongCodec], - "List_StackTraceElement": [PathHolders.ListMultiFrameCodec, PathHolders.StackTraceElementCodec], - "List_String": [PathHolders.ListMultiFrameCodec, PathHolders.StringCodec], - "List_UUID": [PathHolders.ListUUIDCodec], - "Map_EndpointQualifier_Address": [PathHolders.MapCodec, PathHolders.EndpointQualifierCodec, PathHolders.AddressCodec], - "Map_String_String": [PathHolders.MapCodec, PathHolders.StringCodec], - "MemberInfo": [PathHolders.MemberInfo, PathHolders.MemberInfoCodec], - "MemberVersion": [PathHolders.MemberVersion, PathHolders.MemberVersionCodec], - "PagingPredicateHolder": [PathHolders.PagingPredicateHolder, PathHolders.PagingPredicateHolderCodec], - "RaftGroupId": [PathHolders.RaftGroupId, PathHolders.RaftGroupIdCodec], - "SimpleEntryView": [PathHolders.SimpleEntryView, PathHolders.SimpleEntryViewCodec], - "StackTraceElement": [PathHolders.StackTraceElement, PathHolders.StackTraceElementCodec], - "String": [PathHolders.StringCodec], - "UUID": [PathHolders.UUID], - "byteArray": [PathHolders.ByteArrayCodec], - "longArray": [PathHolders.LongArrayCodec], - 'List_MemberInfo': [PathHolders.MemberInfo, PathHolders.ListMultiFrameCodec, PathHolders.MemberInfoCodec], - "List_SqlColumnMetadata": [PathHolders.ListSqlColumnMetadata, PathHolders.SqlColumnMetadataCodec], - "SqlError": [PathHolders.SqlError, PathHolders.SqlErrorCodec], - "SqlQueryId": [PathHolders.SqlQueryId, PathHolders.SqlQueryIdCodec], - "SqlPage": [PathHolders.SqlPage, PathHolders.SqlPageCodec], - "SqlColumnMetadata": [PathHolders.SqlColumnMetadata, PathHolders.SqlColumnMetadataCodec], - -} - -_go_types_common = { - "Address": "cluster.Address", - "AnchorDataListHolder": "NA", - # "AttributeConfig": "NA", - "BitmapIndexOptions": "types.BitmapIndexOptions", - # "CacheConfigHolder": "NA", - # "CacheEventData": "NA", - # "CacheSimpleEntryListenerConfig": "NA", - # "ClientBwListEntry": "NA", - "Data": "*iserialization.Data", - "DistributedObjectInfo": "types.DistributedObjectInfo", - # "DurationConfig": "NA", - "EndpointQualifier": "cluster.EndpointQualifier", - "ErrorHolder": "proto.ErrorHolder", - # "EventJournalConfig": "NA", - # "EvictionConfigHolder": "NA", - # "HotRestartConfig": "NA", - "IndexConfig": "types.IndexConfig", - "Integer": "int32", - # "List_CPMember": "NA", - # "ListenerConfigHolder": "NA", - "Long": "int64", - # "MapStoreConfigHolder": "NA", - "Map_EndpointQualifier_Address": "map[cluster.EndpointQualifier]cluster.Address", - "Map_String_String": "map[string]string", - "MemberInfo": "cluster.MemberInfo", - # "MergePolicyConfig": "NA", - # "MerkleTreeConfig": "NA", - # "NearCacheConfigHolder": "NA", - # "NearCachePreloaderConfig": "NA", - "Pair": "proto.Pair", - # "PredicateConfigHolder": "NA", - # "QueryCacheConfigHolder": "NA", - # "QueueStoreConfigHolder": "NA", - # "RaftGroupId": "proto.RaftGroupId", - # "RingbufferStoreConfigHolder": "NA", - "SimpleEntryView": "*types.SimpleEntryView", - "StackTraceElement": "ihzerrors.StackTraceElement", - "String": "string", - # "TimedExpiryPolicyFactoryConfig": "NA", - "UUID": "types.UUID", - # "WanReplicationRef": "NA", - "boolean": "bool", - "byte": "byte", - "byteArray": "[]byte", - "int": "int32", - "long": "int64", - "longArray": "[]int64", - "ListCN_Data": "[]*iserialization.Data", - "List_ListCN_Data": "[]*iserialization.Data", - "List_SqlColumnMetadata": "[]sql.ColumnMetadata", - "SqlError": "isql.Error", - "SqlQueryId": "isql.QueryID", - "SqlPage": "isql.Page", - "SqlColumnMetadata": "sql.ColumnMetadata", -} - -_go_types_encode = { - # "AnchorDataListHolder": "proto.AnchorDataListHolder", - "AnchorDataListHolder": "NA", - # "CPMember": "NA", - # "CacheEventData": "NA", - # "ClientBwListEntry": "NA", - "EntryList_Data_Data": "[]proto.Pair", - "EntryList_Data_List_Data": "[]proto.Pair", - "EntryList_Integer_Integer": "[]proto.Pair", - "EntryList_Integer_Long": "[]proto.Pair", - "EntryList_Integer_UUID": "[]proto.Pair", - "EntryList_Long_byteArray": "[]proto.Pair", - "EntryList_String_EntryList_Integer_Long": "[]proto.Pair", - "EntryList_String_String": "[]proto.Pair", - "EntryList_String_byteArray": "[]proto.Pair", - "EntryList_UUID_List_Integer": "[]proto.Pair", - "EntryList_UUID_Long": "[]proto.Pair", - "EntryList_UUID_UUID": "[]proto.Pair", - "List_AttributeConfig": "NA", - # "List_CacheEventData": "NA", - # "List_CacheSimpleEntryListenerConfig": "NA", - # "List_ClientBwListEntry": "NA", - "List_Data": "[]*iserialization.Data", - "List_DistributedObjectInfo": "[]types.DistributedObjectInfo", - "List_IndexConfig": "[]types.IndexConfig", - "List_Integer": "[]int32", - "List_List_Data": "[]*iserialization.Data", - # "List_ListenerConfigHolder": "NA", - "List_Long": "[]int64", - # "List_MCEvent": "NA", - "List_MemberInfo": "[]cluster.MemberInfo", - # "List_QueryCacheConfigHolder": "NA", - # "List_QueryCacheEventData": "NA", - # "List_ScheduledTaskHandler": "NA", - "List_StackTraceElement": "[]ihzerrors.StackTraceElement", - "List_String": "[]string", - "List_UUID": "[]types.UUID", - # "List_Xid": "NA", - # "MCEvent": "NA", - "MemberInfo": "cluster.MemberInfo", - "MemberVersion": "cluster.MemberVersion", - # "MigrationState": "NA", - # "PagingPredicateHolder": "proto.PagingPredicateHolder", - "PagingPredicateHolder": "NA", - # "QueryCacheEventData": "NA", - # "ScheduledTaskHandler": "NA", - # "Xid": "NA", -} - -_go_types_decode = { - # "Address": "cluster.Address", - # "CPMember": "NA", - # "CacheEventData": "NA", - # "ClientBwListEntry": "NA", - "EntryList_Data_Data": "[]proto.Pair", - "EntryList_Data_List_Data": "[]proto.Pair", - "EntryList_Integer_Integer": "[]proto.Pair", - "EntryList_Integer_Long": "[]proto.Pair", - "EntryList_Integer_UUID": "[]proto.Pair", - "EntryList_Long_byteArray": "[]proto.Pair", - "EntryList_String_EntryList_Integer_Long": "[]proto.Pair", - "EntryList_String_String": "[]proto.Pair", - "EntryList_String_byteArray": "[]proto.Pair", - "EntryList_UUID_List_Integer": "[]proto.Pair", - "EntryList_UUID_Long": "[]proto.Pair", - "EntryList_UUID_UUID": "[]proto.Pair", - # "ListCN_Data": "[]*iserialization.Data", - "List_AttributeConfig": "NA", - # "List_CPMember": "NA", - # "List_CacheEventData": "NA", - # "List_CacheSimpleEntryListenerConfig": "NA", - # "List_ClientBwListEntry": "NA", - "List_Data": "[]*iserialization.Data", - "List_DistributedObjectInfo": "[]types.DistributedObjectInfo", - "List_IndexConfig": "[]types.IndexConfig", - "List_Integer": "[]int32", - # "List_ListCN_Data": "NA", - "List_List_Data": "[]*iserialization.Data", - # "List_ListenerConfigHolder": "NA", - "List_Long": "[]int64", - # "List_MCEvent": "NA", - "List_MemberInfo": "[]cluster.MemberInfo", - # "List_QueryCacheConfigHolder": "NA", - # "List_QueryCacheEventData": "NA", - # "List_ScheduledTaskHandler": "NA", - # "List_SqlColumnMetadata": "NA", - "List_StackTraceElement": "[]ihzerrors.StackTraceElement", - "List_String": "[]string", - "List_UUID": "[]types.UUID", - # "List_Xid": "NA", - # "MCEvent": "NA", - "MemberInfo": "cluster.MemberInfo", - "MemberVersion": "cluster.MemberVersion", - # "MigrationState": "NA", - # "PagingPredicateHolder": "proto.PagingPredicateHolder", - # "QueryCacheEventData": "NA", - # "ScheduledTaskHandler": "NA", - # "SqlColumnMetadata": "NA", - # "SqlError": "NA", - # "SqlQueryId": "NA", - # "Xid": "NA", -} - - -def go_augment_enum(codec, param): - cast_type = _go_enum.get((codec, param["name"])) - if cast_type: - return "%s(%s)" % (cast_type, go_escape_keyword(param["name"])) - return go_escape_keyword(param["name"]) - - -_go_enum = { - ("BitmapIndexOptions", "uniqueKeyTransformation"): "types.UniqueKeyTransformation", - ("EndpointQualifier", "type"): "cluster.EndpointQualifierType", - ("IndexConfig", "type"): "types.IndexType", -} - -def go_rename_field(codec, param): - name = param["name"] - field_name = _go_field.get((codec, name)) - if field_name: - return field_name - return "%s%s" % (name[0].upper(), name[1:]) - -_go_field = { - ("SimpleEntryView", "ttl"): "TTL", - ("MemberInfo", "uuid"): "UUID", -} \ No newline at end of file +from .generator import GoGenerator diff --git a/go/codec-template.go.j2 b/go/codec-template.j2 similarity index 88% rename from go/codec-template.go.j2 rename to go/codec-template.j2 index 667b29d27..ed2310033 100644 --- a/go/codec-template.go.j2 +++ b/go/codec-template.j2 @@ -8,9 +8,9 @@ {%- else -%} {%- if param.nullable -%} {%- if param.type|lower == "string" -%} - CodecUtil.EncodeNullableForString(clientMessage, {{ param_name(param.name) }}) + EncodeNullableForString(clientMessage, {{ param_name(param.name) }}) {%- else -%} - CodecUtil.EncodeNullable(clientMessage, {{ param_name(param.name) }}, Encode{{ lang_name(param.type) }}{% if loop_last %}, True{% endif %}) + EncodeNullable(clientMessage, {{ param_name(param.name) }}, Encode{{ lang_name(param.type) }}{% if loop_last %}, True{% endif %}) {%- endif -%} {%- else -%} Encode{{ lang_name(param.type) }}(clientMessage, {{ param_name(param.name) }}{% if loop_last %}, True{% endif %}) @@ -26,7 +26,7 @@ Decode{% if param.nullable %}Nullable{% endif %}Map(v, Decode{{ key_type(lang_name, param.type) }}, Decode{{ value_type(lang_name, param.type) }}) {%- else -%} {%- if param.nullable -%} - CodecUtil.DecodeNullableFor{{ lang_name(param.type) }}(frameIterator) + DecodeNullableFor{{ lang_name(param.type) }}(frameIterator) {%- else -%} Decode{{ lang_name(param.type) }}(frameIterator) {%- endif -%} @@ -53,7 +53,7 @@ import ( {% endfor %} {% endif %} /* -* Copyright (c) 2008-2020, Hazelcast, Inc. All Rights Reserved. +* Copyright (c) 2008-{{ copyright_year }}, Hazelcast, Inc. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License") * you may not use this file except in compliance with the License. @@ -126,7 +126,7 @@ func Encode{{ service_name|capital }}{{ method.name|capital }}Request({% for par initialFrame := proto.NewFrameWith(make([]byte, {{ service_name|capital }}{{ method.name|capital }}CodecRequestInitialFrameSize), proto.UnfragmentedMessage) {% for param in request_fix_sized_params %} - FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset, {{ escape_keyword(param.name) }}) + Encode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}CodecRequest{{ param.name|capital }}Offset, {{ escape_keyword(param.name) }}) {% endfor %} clientMessage.AddFrame(initialFrame) clientMessage.SetMessageType({{ service_name|capital }}{{ method.name|capital }}CodecRequestMessageType) @@ -153,7 +153,7 @@ func Decode{{ service_name|capital }}{{ method.name|capital }}Response(clientMes {% endif %} {% for param in response_fix_sized_params %} - return FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Response{{param.name|capital}}Offset) + return Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Response{{param.name|capital}}Offset) {% endfor %} {% for param in response_var_sized_params %} return {{ decode_var_sized(param) }} @@ -172,13 +172,13 @@ func Decode{{ service_name|capital }}{{ method.name|capital }}Response(clientMes {% for param in response_fix_sized_params %} {% if param in response_new_params %} if (initialFrame.content.length >= RESPONSE_{{ to_upper_snake_case(param.name) }}_OFFSET + BitsUtil.{{ param.type.upper() }}_SIZE_IN_BYTES) { - response.{{ escape_keyword(param.name) }} = FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, RESPONSE_{{to_upper_snake_case(param.name)}}_OFFSET); + response.{{ escape_keyword(param.name) }} = Decode{{ param.type|capital }}(initialFrame.Content, RESPONSE_{{to_upper_snake_case(param.name)}}_OFFSET); response.is{{ param.name|capital }}Exists = true; } else { response.is{{ param.name|capital }}Exists = false; } {% else %} - {{ escape_keyword(param.name) }} = FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Response{{ param.name|capital }}Offset) + {{ escape_keyword(param.name) }} = Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Response{{ param.name|capital }}Offset) {% endif %} {% endfor %} {% for param in response_var_sized_params %} @@ -217,11 +217,11 @@ func Handle{{ service_name|capital }}{{ method.name|capital }}(clientMessage *pr let is{{ param.name|capital }}Exists = false let {{ escape_keyword(param.name) }} = {% if param.type == 'boolean' %}false{% elif param.type == 'UUID' %}null{% else %}0{% endif %} if (initialFrame.content.length >= EVENT_{{ to_upper_snake_case(event.name)}}_{{ to_upper_snake_case(param.name) }}_OFFSET + BitsUtil.{{ param.type.upper() }}_SIZE_IN_BYTES) { - {{ escape_keyword(param.name) }} = FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.content, EVENT_{{ to_upper_snake_case(event.name)}}_{{ to_upper_snake_case(param.name) }}_OFFSET) + {{ escape_keyword(param.name) }} = Decode{{ param.type|capital }}(initialFrame.content, EVENT_{{ to_upper_snake_case(event.name)}}_{{ to_upper_snake_case(param.name) }}_OFFSET) is{{ param.name|capital }}Exists = true; } {% else %} - {{ escape_keyword(param.name) }} := FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Event{{ event.name|capital }}{{param.name|capital}}Offset) + {{ escape_keyword(param.name) }} := Decode{{ param.type|capital }}(initialFrame.Content, {{ service_name|capital }}{{ method.name|capital }}Event{{ event.name|capital }}{{param.name|capital}}Offset) {% endif %} {% endfor %} {% for param in var_size_params(event.params) %} diff --git a/util.py b/util.py index f05b4cee4..5876c2c4f 100644 --- a/util.py +++ b/util.py @@ -17,8 +17,6 @@ from cpp import cpp_ignore_service_list, cpp_types_decode, cpp_types_encode, get_size, is_trivial from cs import cs_escape_keyword, cs_ignore_service_list, cs_types_decode, cs_types_encode from java import java_types_decode, java_types_encode -from go import go_types_encode, go_types_decode, go_ignore_service_list, \ - go_get_import_statements, go_escape_keyword, go_augment_enum, go_rename_field from md import internal_services from py import ( py_escape_keyword, @@ -438,7 +436,7 @@ def get_protocol_versions(protocol_defs, custom_codec_defs): return map(str, protocol_versions) -def copy_verbatim_files(output_dir, lang, env): +def copy_verbatim_files(output_dir, lang): cur_dir = os.path.dirname(os.path.realpath(__file__)) lang_dir = os.path.join(cur_dir, lang) verbatim_dir = os.path.join(lang_dir, "verbatim") @@ -448,12 +446,6 @@ def copy_verbatim_files(output_dir, lang, env): # creating directories if necessary print("Verbatim files found, copying from %s to %s" % (verbatim_dir, output_dir)) copy_tree(verbatim_dir, output_dir) - # shutil.copytree( - # verbatim_dir, - # output_dir, - # ignore=shutil.ignore_patterns(".*"), - # dirs_exist_ok=True - # ) class SupportedLanguages(Enum): @@ -506,7 +498,6 @@ def inner(*names): SupportedLanguages.CS: _capitalized_name_generator('cs'), SupportedLanguages.PY: _snake_cased_name_generator('py'), SupportedLanguages.TS: _capitalized_name_generator('ts'), - SupportedLanguages.GO: _snake_cased_name_generator('go'), SupportedLanguages.MD: "md", } @@ -517,7 +508,6 @@ def inner(*names): SupportedLanguages.CPP: cpp_types_encode, SupportedLanguages.TS: ts_types_encode, SupportedLanguages.PY: py_types_encode_decode, - SupportedLanguages.GO: go_types_encode, SupportedLanguages.MD: lambda x: x, }, "lang_types_decode": { @@ -526,7 +516,6 @@ def inner(*names): SupportedLanguages.CPP: cpp_types_decode, SupportedLanguages.TS: ts_types_decode, SupportedLanguages.PY: py_types_encode_decode, - SupportedLanguages.GO: go_types_decode, SupportedLanguages.MD: lambda x: x, }, "lang_name": { @@ -535,7 +524,6 @@ def inner(*names): SupportedLanguages.CPP: cpp_name, SupportedLanguages.TS: java_name, SupportedLanguages.PY: java_name, - SupportedLanguages.GO: java_name, SupportedLanguages.MD: lambda x: x, }, "param_name": { @@ -544,7 +532,6 @@ def inner(*names): SupportedLanguages.CPP: param_name, SupportedLanguages.TS: param_name, SupportedLanguages.PY: py_param_name, - SupportedLanguages.GO: param_name, SupportedLanguages.MD: lambda x: x, }, "escape_keyword": { @@ -553,7 +540,6 @@ def inner(*names): SupportedLanguages.CPP: lambda x: x, SupportedLanguages.TS: ts_escape_keyword, SupportedLanguages.PY: py_escape_keyword, - SupportedLanguages.GO: go_escape_keyword, SupportedLanguages.MD: lambda x: x, }, "get_import_path_holders": { @@ -562,22 +548,14 @@ def inner(*names): SupportedLanguages.CPP: lambda x: x, SupportedLanguages.TS: ts_get_import_path_holders, SupportedLanguages.PY: py_get_import_path_holders, - SupportedLanguages.GO: go_get_import_statements, # exposed as: get_import_path_holders SupportedLanguages.MD: lambda x: x, }, - "augment_enum": { - SupportedLanguages.GO: go_augment_enum, - }, - "rename_field": { - SupportedLanguages.GO: go_rename_field, - }, "custom_type_name": { SupportedLanguages.JAVA: lambda x: x, SupportedLanguages.CS: lambda x: x, SupportedLanguages.CPP: lambda x: x, SupportedLanguages.TS: lambda x: x, SupportedLanguages.PY: py_custom_type_name, - SupportedLanguages.GO: lambda x: x, SupportedLanguages.MD: lambda x: x, } } @@ -588,7 +566,6 @@ def inner(*names): SupportedLanguages.CS: cs_ignore_service_list, SupportedLanguages.PY: py_ignore_service_list, SupportedLanguages.TS: ts_ignore_service_list, - SupportedLanguages.GO: go_ignore_service_list, } From 0ab13572efe3cd73a003002f250300f6e867c9bb Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Tue, 15 Feb 2022 09:46:11 +0300 Subject: [PATCH 26/41] Added missing Go generator files --- go/config.json | 3 + go/config.py | 21 +++ go/generator.py | 290 ++++++++++++++++++++++++++++++++ tests/fixtures/hzpo-config.json | 4 + 4 files changed, 318 insertions(+) create mode 100644 go/config.json create mode 100644 go/config.py create mode 100644 go/generator.py create mode 100644 tests/fixtures/hzpo-config.json diff --git a/go/config.json b/go/config.json new file mode 100644 index 000000000..6b3dea67d --- /dev/null +++ b/go/config.json @@ -0,0 +1,3 @@ +{ + "include_methods": ["SQL.*"] +} \ No newline at end of file diff --git a/go/config.py b/go/config.py new file mode 100644 index 000000000..1dcd245ed --- /dev/null +++ b/go/config.py @@ -0,0 +1,21 @@ + +DEFAULT_IMPORT_PATH = "github.com/hazelcast/hazelcast-go-client" + + +class Config: + + def __init__(self, base_import_path="", include_methods=None, mapping=None, override_imports=None): + self.base_import_path = base_import_path or DEFAULT_IMPORT_PATH + self.include_methods = include_methods or [] + self.mapping = mapping or {} + self.override_imports = override_imports or {} + + @classmethod + def from_json(cls, d: dict): + keys = [ + "base_import_path", + "include_methods", + "mapping", + "override_imports", + ] + return cls(**{k: d.get(k) for k in keys}) \ No newline at end of file diff --git a/go/generator.py b/go/generator.py new file mode 100644 index 000000000..35026178f --- /dev/null +++ b/go/generator.py @@ -0,0 +1,290 @@ +import hashlib +import json +import os +import fnmatch +from datetime import datetime + +from jinja2 import Environment, PackageLoader + +from cpp import get_size, is_trivial +from util import _snake_cased_name_generator, capital, to_upper_snake_case, is_var_sized_list_contains_nullable, \ + fixed_params, var_size_params, new_params, filter_new_params, is_var_sized_list, is_var_sized_entry_list, \ + is_var_sized_map, item_type, key_type, value_type, param_name, java_name +from .config import Config + + +class GoGenerator: + + filename_gen = _snake_cased_name_generator("go") + + def __init__(self, services, output_dir, args): + self.services = services + self.output_dir = output_dir + self.args = args + config_path = args.go_config + self.extensibility = True + if not config_path: + config_path = os.path.join(current_path(), "config.json") + self.extensibility = False + self.config = self.load_config(config_path) + self.types_encode = self.make_types_encode(types) + self.types_decode = self.make_types_decode(types) + + def generate(self): + for service in self.services: + self.generate_service(service) + + def generate_service(self, service): + env = self.make_environment() + template = env.get_template("codec-template.j2") + methods = service.get("methods") + if methods is None: + raise NotImplementedError(f"Methods not found for service {service}") + for method in methods: + self.generate_method(service, method, template) + + def generate_method(self, service, method, template): + name = f"{service['name']}.{method['name']}" + if not self.can_generate_method(name): + return + opts = { + "base_import_path": self.config.base_import_path + } + method["request"]["id"] = self.make_id(service["id"], method["id"], 0) + method["response"]["id"] = self.make_id(service["id"], method["id"], 1) + for i, event in enumerate(method.get("events", [])): + event["id"] = self.make_id(service["id"], method["id"], i + 2) + codec_file_name = GoGenerator.filename_gen(service["name"], method["name"]) + try: + content = template.render(service_name=service["name"], method=method, **opts) + path = os.path.join(self.output_dir, codec_file_name) + self.save(path, content) + except NotImplementedError as e: + print(f"{codec_file_name} contains missing type mapping so ignoring it. Error: {e}") + + def can_generate_method(self, method_name: str) -> bool: + for filter in self.config.include_methods: + if fnmatch.fnmatch(method_name.lower(), filter.lower()): + return True + return False + + @classmethod + def load_config(cls, path: str) -> Config: + with open(path) as f: + d = json.loads(f.read()) + return Config.from_json(d) + + @classmethod + def render(cls, service, template, method, **opts): + return template.render(service_name=service["name"], method=method, **opts) + + @classmethod + def save(cls, path: str, content: str, mode="w"): + m = hashlib.md5() + m.update(content.encode("utf-8")) + codec_hash = m.hexdigest() + with open(path, mode, newline=os.linesep) as path: + path.writelines(content.replace("!codec_hash!", codec_hash)) + + @classmethod + def make_id(cls, service_id, method_id, seq) -> int: + return int(f"0x{service_id:02x}{method_id:02x}{seq:02x}", 16) + + def make_environment(self): + env = Environment( + loader=PackageLoader("go", current_path()), + extensions=["jinja2.ext.do", "jinja2.ext.loopcontrols"], + ) + env.trim_blocks = True + env.lstrip_blocks = True + env.keep_trailing_newline = False + env.filters["capital"] = capital + env.globals["to_upper_snake_case"] = to_upper_snake_case + env.globals["fixed_params"] = fixed_params + env.globals["var_size_params"] = var_size_params + env.globals["new_params"] = new_params + env.globals["filter_new_params"] = filter_new_params + env.globals["is_var_sized_list"] = is_var_sized_list + env.globals["is_var_sized_list_contains_nullable"] = is_var_sized_list_contains_nullable + env.globals["is_var_sized_entry_list"] = is_var_sized_entry_list + env.globals["is_var_sized_map"] = is_var_sized_map + env.globals["item_type"] = item_type + env.globals["key_type"] = key_type + env.globals["value_type"] = value_type + env.globals["lang_types_encode"] = self.go_types_encode + env.globals["lang_types_decode"] = self.go_types_decode + env.globals["lang_name"] = java_name + env.globals["param_name"] = param_name + env.globals["escape_keyword"] = go_escape_keyword + env.globals["get_size"] = get_size + env.globals["is_trivial"] = is_trivial + env.globals["get_import_path_holders"] = self.go_get_import_statements + env.globals["augment_enum"] = go_augment_enum + env.globals["rename_field"] = go_rename_field + env.globals["copyright_year"] = datetime.now().year + return env + + def make_import_stmts_mapping(self, types: dict) -> dict: + bip = self.config.base_import_path + stmts = {} + for package, ts in types.get("public", {}).items(): + for t in ts: + stmts[t] = f"/{package}" + for package, ts in types.get("internal", {}).items(): + for t in ts: + stmts[t] = f"/internal/{package}" + for t, path in stmts.items(): + pp = path.split("/") + package = pp[-1] + alias = f"pub{package}" + if "internal" in pp: + alias = f"i{package}" + stmts[t] = f'{alias} "{bip}{path}"' + if self.extensibility: + stmts["Data"] = 'iserialization "github.com/hazelcast/hazelcast-go-client"' + return stmts + + def make_types_encode(self, types: dict): + res = {} + for package, ts in types.get("public", {}).items(): + for t in ts: + res[t] = f"pub{package}.{t}" + for package, ts in types.get("internal", {}).items(): + for t in ts: + res[t] = f"i{package}.{t}" + for from_type, to_type in DEFAULT_MAPPING.items(): + res[from_type] = to_type + for from_type, to_type in self.config.mapping.items(): + res[from_type] = to_type + # if self.extensibility: + # res["Data"] = "hazelcast.Data" + return res + + make_types_decode = make_types_encode + + # def make_types_decode(self, types: dict): + # res = {} + # for package, ts in types.get("public", {}).items(): + # for t in ts: + # res[t] = f"pub{package}.{t}" + # for package, ts in types.get("internal", {}).items(): + # for t in ts: + # res[t] = f"i{package}.{t}" + # for from_type, to_type in self.config.mapping.items(): + # res[from_type] = to_type + # if self.extensibility: + # res["Data"] = "hazelcast.Data" + # return res + + def go_get_import_statements(self, *args): + import_map = self.make_import_stmts_mapping(types) + import_statements = set() + for arg in args: + params = [arg] if isinstance(arg, str) else arg + for param in params: + type = param["type"] if isinstance(param, dict) else param + import_stmt = import_map.get(type) + if import_stmt is None: + # this may be a mapped type + mt = DEFAULT_MAPPING.get(type) + if mt: + p = mt.split(".", 1) + if len(p) == 2: + import_stmt = import_map.get(p[1]) + if import_stmt: + import_statements.add(import_stmt) + if not import_stmt: + continue + # TODO: adapt the proto import path according to GOCE. + if self.extensibility: + import_statements.add('proto "github.com/hazelcast/hazelcast-go-client"') + else: + import_statements.add('"github.com/hazelcast/hazelcast-go-client/internal/proto"') + # if args[0] == "SimpleEntryView": + # import_statements.remove('iserialization"github.com/hazelcast/hazelcast-go-client/internal/serialization"') + return sorted(import_statements) + + def go_types_encode(self, key): + try: + return self.types_encode[key] + except KeyError: + raise NotImplementedError(f"Missing type mapping for '{key}'") + + def go_types_decode(self, key): + try: + return self.types_decode[key] + except KeyError: + raise NotImplementedError(f"Missing type mapping for '{key}'") + + +def current_path(): + return os.path.split(os.path.abspath(__file__))[0] + + +go_reserved_keywords = {"break", "default", "func", "interface", "select", "case", "defer", "go", "map", "struct", + "chan", "else", "goto", "package", "switch", "const", "fallthrough", "if", "range", "type", + "continue", "for", "import", "return", "var"} + +types = { + "builtin": [ + "ByteArrayCodec", "CodecUtil", "DataCodec", + ], + "public": { + "cluster": ["Address", "EndpointQualifier", "MemberInfo", "MemberVersion"], + "sql": ["ListSqlColumnMetadata", "SqlColumnMetadata"], + "types": [ + "BitmapIndexOptions", "DistributedObjectInfo", "IndexConfig", + "SimpleEntryView", "UUID" + ], + }, + "internal": { + "hzerrors": ["StackTraceElement"], + "serialization": ["Data"], + "sql": ["Error", "Page", "QueryID"] + } +} + + +_go_enum = { + ("BitmapIndexOptions", "uniqueKeyTransformation"): "types.UniqueKeyTransformation", + ("EndpointQualifier", "type"): "cluster.EndpointQualifierType", + ("IndexConfig", "type"): "types.IndexType", +} + +_go_field = { + ("SimpleEntryView", "ttl"): "TTL", + ("MemberInfo", "uuid"): "UUID", +} + + +def go_escape_keyword(value): + if value not in go_reserved_keywords: + return value + return "_%s" % value + + +def go_augment_enum(codec, param): + cast_type = _go_enum.get((codec, param["name"])) + if cast_type: + return "%s(%s)" % (cast_type, go_escape_keyword(param["name"])) + return go_escape_keyword(param["name"]) + + +def go_rename_field(codec, param): + name = param["name"] + field_name = _go_field.get((codec, name)) + if field_name: + return field_name + return "%s%s" % (name[0].upper(), name[1:]) + + +DEFAULT_MAPPING = { + "boolean": "bool", + "EntryList_Data_Data": "[]proto.Pair", + "EntryList_Integer_Integer": "[]proto.Pair", + "int": "int32", + "List_Data": "[]iserialization.Data", + "long": "int64", + "SqlQueryId": "isql.QueryID", + "String": "string", +} diff --git a/tests/fixtures/hzpo-config.json b/tests/fixtures/hzpo-config.json new file mode 100644 index 000000000..c0e7cef36 --- /dev/null +++ b/tests/fixtures/hzpo-config.json @@ -0,0 +1,4 @@ +{ + "base_import_path": "github.com/hazelcast/hazelcast-platform-operator", + "include_methods": ["Map.getAll"] +} \ No newline at end of file From 03065cf5a1c1cabdbb0be8cfb5aa9aec89fe4347 Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Wed, 16 Feb 2022 17:03:24 +0300 Subject: [PATCH 27/41] Updates --- generator.py | 4 +- go/config.json | 3 +- go/config.py | 6 +- ...emplate.go.j2 => custom-codec-template.j2} | 16 +-- go/generator.py | 70 ++++++++--- tests/fixtures/hzpo-config.json | 21 +++- tests/test_go_generator.py | 113 ++++++++++++++++++ util.py | 5 - 8 files changed, 205 insertions(+), 33 deletions(-) rename go/{custom-codec-template.go.j2 => custom-codec-template.j2} (87%) create mode 100644 tests/test_go_generator.py diff --git a/generator.py b/generator.py index 93081d85f..d5783e45b 100755 --- a/generator.py +++ b/generator.py @@ -174,7 +174,7 @@ copy_verbatim_files(codec_output_dir, lang.value) if lang == SupportedLanguages.GO: - gen = GoGenerator(protocol_defs, codec_output_dir, args) + gen = GoGenerator(protocol_defs, custom_protocol_defs, codec_output_dir, args) gen.generate() exit(0) @@ -183,7 +183,7 @@ if lang != SupportedLanguages.MD: codec_template = env.get_template("codec-template.%s.j2" % lang.value) - generate_codecs(protocol_defs, codec_template, codec_output_dir, lang, env, args) + generate_codecs(protocol_defs, codec_template, codec_output_dir, lang, env) print("Generated codecs are at '%s'" % abspath(codec_output_dir)) if custom_protocol_defs: diff --git a/go/config.json b/go/config.json index 6b3dea67d..ea35fa1ed 100644 --- a/go/config.json +++ b/go/config.json @@ -1,3 +1,4 @@ { - "include_methods": ["SQL.*"] + "include_methods": ["SQL.*"], + "include_types": ["Address"] } \ No newline at end of file diff --git a/go/config.py b/go/config.py index 1dcd245ed..e1e1e920b 100644 --- a/go/config.py +++ b/go/config.py @@ -4,18 +4,22 @@ class Config: - def __init__(self, base_import_path="", include_methods=None, mapping=None, override_imports=None): + def __init__(self, base_import_path="", include_methods=None, include_types=None, mapping=None, override_imports=None, types=None): self.base_import_path = base_import_path or DEFAULT_IMPORT_PATH self.include_methods = include_methods or [] + self.include_types = include_types or [] self.mapping = mapping or {} self.override_imports = override_imports or {} + self.types = types or {} @classmethod def from_json(cls, d: dict): keys = [ "base_import_path", "include_methods", + "include_types", "mapping", "override_imports", + "types" ] return cls(**{k: d.get(k) for k in keys}) \ No newline at end of file diff --git a/go/custom-codec-template.go.j2 b/go/custom-codec-template.j2 similarity index 87% rename from go/custom-codec-template.go.j2 rename to go/custom-codec-template.j2 index 70b53c456..02439f922 100644 --- a/go/custom-codec-template.go.j2 +++ b/go/custom-codec-template.j2 @@ -7,7 +7,7 @@ Encode{% if param.nullable %}Nullable{% endif %}MapFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}) {%- else -%} {%- if param.nullable -%} - CodecUtil.EncodeNullableFor{{ lang_name(param.type) }}(clientMessage, {% if param.type != "String" %}&{% endif %}{{ param_name(codec.name)}}.{{ param.name|capital }}) + EncodeNullableFor{{ lang_name(param.type) }}(clientMessage, {% if param.type != "String" %}&{% endif %}{{ param_name(codec.name)}}.{{ param.name|capital }}) {%- else -%} Encode{{ lang_name(param.type) }}(clientMessage, {{ param_name(codec.name)}}.{{ param.name|capital }}) {%- endif %} @@ -22,7 +22,7 @@ Decode{% if param.nullable %}Nullable{% endif %}MapFor{{ key_type(lang_name, param.type) }}And{{ value_type(lang_name, param.type) }}(frameIterator) {%- else -%} {%- if param.nullable -%} - CodecUtil.DecodeNullableFor{{ lang_name(param.type) }}(frameIterator) + DecodeNullableFor{{ lang_name(param.type) }}(frameIterator) {%- else -%} Decode{{ lang_name(param.type) }}(frameIterator) {%- endif -%} @@ -41,7 +41,7 @@ import ( {% set fix_sized_new_params = new_params(codec.since, fix_sized_params) %} {% set should_add_begin_frame = (fix_sized_params|length > fix_sized_new_params|length) or fix_sized_params|length == 0 %} /* -* Copyright (c) 2008-2020, Hazelcast, Inc. All Rights Reserved. +* Copyright (c) 2008-{{ copyright_year }}, Hazelcast, Inc. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License") * you may not use this file except in compliance with the License. @@ -102,7 +102,7 @@ func Encode{{ codec.name|capital }}(clientMessage *proto.ClientMessage, {{ param {% else %} {% set cast = "" %} {% endif %} - FixSizedTypesCodec.Encode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset, {% if cast %}{{ cast }}{% endif %}{{ param_name(codec.name)}}.{{ rename_field(codec.name, param) }}{% if cast %}){% endif %}) + Encode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset, {% if cast %}{{ cast }}{% endif %}{{ param_name(codec.name)}}.{{ rename_field(codec.name, param) }}{% if cast %}){% endif %}) {% if loop.last %} {% if not should_add_begin_frame %} initialFrame.flags |= BEGIN_DATA_STRUCTURE_FLAG @@ -136,10 +136,10 @@ func Decode{{ codec.name|capital }}(frameIterator *proto.ForwardFrameIterator) { {% if param in fix_sized_new_params %} let {{ escape_keyword(param.name) }} = {% if param.type == 'boolean' %}false{% elif param.type == 'UUID' %}null{% else %}0{% endif %} if (initialFrame.content.length >= {{ to_upper_snake_case(param.name) }}_OFFSET + BitsUtil.{{ param.type.upper() }}_SIZE_IN_BYTES) { - {{ escape_keyword(param.name) }} = FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ to_upper_snake_case(param.name) }}_OFFSET) + {{ escape_keyword(param.name) }} = Decode{{ param.type|capital }}(initialFrame.Content, {{ to_upper_snake_case(param.name) }}_OFFSET) } {% else %} - {{ escape_keyword(param.name) }} := FixSizedTypesCodec.Decode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset) + {{ escape_keyword(param.name) }} := Decode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset) {% endif %} {% endfor %} {% for param in var_sized_params %} @@ -158,7 +158,7 @@ func Decode{{ codec.name|capital }}(frameIterator *proto.ForwardFrameIterator) { {{ escape_keyword(param.name) }} := {{ decode_var_sized(param) }} {% endif %} {% endfor %} - CodecUtil.FastForwardToEndFrame(frameIterator) + FastForwardToEndFrame(frameIterator) {% set ctor_params = [] %} {% for param in codec.params %} {% if lang_types_decode(param.type) != '!skip' %} @@ -170,7 +170,7 @@ func Decode{{ codec.name|capital }}(frameIterator *proto.ForwardFrameIterator) { {% set encoded_codec_name = encoded_codec_name[1:] %} {% endif %} {% if codec.name == "Address"%} - return cluster.NewAddress(host, port) + return pubcluster.NewAddress(host, port) {% else %} return {% if "*" in lang_types_encode(codec.name) %}&{% endif %}{{ encoded_codec_name.split('.')[0] }}.{{ encoded_codec_name.split('.')[1] }}{% raw %}{{%endraw %} diff --git a/go/generator.py b/go/generator.py index 35026178f..9fe9b0aae 100644 --- a/go/generator.py +++ b/go/generator.py @@ -17,8 +17,9 @@ class GoGenerator: filename_gen = _snake_cased_name_generator("go") - def __init__(self, services, output_dir, args): + def __init__(self, services, custom_protocol, output_dir, args): self.services = services + self.custom_types = custom_protocol[0]["customTypes"] self.output_dir = output_dir self.args = args config_path = args.go_config @@ -27,16 +28,22 @@ def __init__(self, services, output_dir, args): config_path = os.path.join(current_path(), "config.json") self.extensibility = False self.config = self.load_config(config_path) - self.types_encode = self.make_types_encode(types) - self.types_decode = self.make_types_decode(types) + self.mapping = DEFAULT_MAPPING.copy() + if self.config.mapping: + self.mapping.update(self.config.mapping) + types = DEFAULT_TYPES.copy() + merge_dict(types, self.config.types) + self.types_encode = self.make_types_encode(DEFAULT_TYPES) + self.types_decode = self.make_types_decode(DEFAULT_TYPES) + self.env = self.make_environment() def generate(self): for service in self.services: self.generate_service(service) + self.generate_types(self.custom_types) def generate_service(self, service): - env = self.make_environment() - template = env.get_template("codec-template.j2") + template = self.env.get_template("codec-template.j2") methods = service.get("methods") if methods is None: raise NotImplementedError(f"Methods not found for service {service}") @@ -47,9 +54,7 @@ def generate_method(self, service, method, template): name = f"{service['name']}.{method['name']}" if not self.can_generate_method(name): return - opts = { - "base_import_path": self.config.base_import_path - } + opts = {"base_import_path": self.config.base_import_path} method["request"]["id"] = self.make_id(service["id"], method["id"], 0) method["response"]["id"] = self.make_id(service["id"], method["id"], 1) for i, event in enumerate(method.get("events", [])): @@ -62,12 +67,33 @@ def generate_method(self, service, method, template): except NotImplementedError as e: print(f"{codec_file_name} contains missing type mapping so ignoring it. Error: {e}") + def generate_types(self, codecs): + template = self.env.get_template("custom-codec-template.j2") + for codec in codecs: + self.generate_type(codec, template) + + def generate_type(self, codec, template): + if not self.can_generate_type(codec["name"]): + return + opts = {"base_import_path": self.config.base_import_path} + codec_file_name = GoGenerator.filename_gen(codec["name"]) + print("Custom:", codec_file_name) + content = template.render(codec=codec, **opts) + path = os.path.join(self.output_dir, codec_file_name) + self.save(path, content) + def can_generate_method(self, method_name: str) -> bool: for filter in self.config.include_methods: if fnmatch.fnmatch(method_name.lower(), filter.lower()): return True return False + def can_generate_type(self, type_name: str) -> bool: + for filter in self.config.include_types: + if fnmatch.fnmatch(type_name.lower(), filter.lower()): + return True + return False + @classmethod def load_config(cls, path: str) -> Config: with open(path) as f: @@ -152,9 +178,7 @@ def make_types_encode(self, types: dict): for package, ts in types.get("internal", {}).items(): for t in ts: res[t] = f"i{package}.{t}" - for from_type, to_type in DEFAULT_MAPPING.items(): - res[from_type] = to_type - for from_type, to_type in self.config.mapping.items(): + for from_type, to_type in self.mapping.items(): res[from_type] = to_type # if self.extensibility: # res["Data"] = "hazelcast.Data" @@ -177,7 +201,7 @@ def make_types_encode(self, types: dict): # return res def go_get_import_statements(self, *args): - import_map = self.make_import_stmts_mapping(types) + import_map = self.make_import_stmts_mapping(DEFAULT_TYPES) import_statements = set() for arg in args: params = [arg] if isinstance(arg, str) else arg @@ -186,7 +210,7 @@ def go_get_import_statements(self, *args): import_stmt = import_map.get(type) if import_stmt is None: # this may be a mapped type - mt = DEFAULT_MAPPING.get(type) + mt = self.mapping.get(type) if mt: p = mt.split(".", 1) if len(p) == 2: @@ -225,7 +249,7 @@ def current_path(): "chan", "else", "goto", "package", "switch", "const", "fallthrough", "if", "range", "type", "continue", "for", "import", "return", "var"} -types = { +DEFAULT_TYPES = { "builtin": [ "ByteArrayCodec", "CodecUtil", "DataCodec", ], @@ -278,13 +302,31 @@ def go_rename_field(codec, param): return "%s%s" % (name[0].upper(), name[1:]) +def merge_dict(d1, d2: dict): + root = d1 + for k, v in d2.items(): + if k in d1: + if isinstance(d1[k], dict) and isinstance(v, dict): + merge_dict(d1[k], v) + continue + root[k] = v + + DEFAULT_MAPPING = { "boolean": "bool", + "byte": "byte", "EntryList_Data_Data": "[]proto.Pair", "EntryList_Integer_Integer": "[]proto.Pair", "int": "int32", + "ListCN_Data": "[]iserialization.Data", "List_Data": "[]iserialization.Data", + "List_IndexConfig": "[]pubtypes.IndexConfig", + "List_ListCN_Data": "[]iserialization.Data", + "List_QueryCacheConfigHolder": "[]QueryCacheConfigHolder", + "List_SqlColumnMetadata": "[]isql.ColumnMetadata", "long": "int64", + "SqlError": "isql.Error", + "SqlPage": "isql.Page", "SqlQueryId": "isql.QueryID", "String": "string", } diff --git a/tests/fixtures/hzpo-config.json b/tests/fixtures/hzpo-config.json index c0e7cef36..5cd347451 100644 --- a/tests/fixtures/hzpo-config.json +++ b/tests/fixtures/hzpo-config.json @@ -1,4 +1,21 @@ { - "base_import_path": "github.com/hazelcast/hazelcast-platform-operator", - "include_methods": ["Map.getAll"] + "base_import_path": "github.com/yuce/hazelcast-go-client-extensibility-sample", + "include_methods": ["Map.getAll", "DynamicConfig.addMapConfig"], + "include_types": ["EventJournalConfig"], + "types": { + "public": { + "control": ["EventJournalConfig"] + } + }, + "mapping": { + "EventJournalConfig": "pubcontrol.EventJournalConfig", + "HotRestartConfig": "pubcontrol.HotRestartConfig", + "EvictionConfigHolder": "pubcontrol.EvictionConfigHolder", + "List_AttributeConfig": "[]pubcontrol.AttributeConfig", + "List_ListenerConfigHolder": "[]pubcontrol.ListenerConfigHolder", + "MapStoreConfigHolder": "pubcontrol.MapStoreConfigHolder", + "MerkleTreeConfig": "pubcontrol.MerkleTreeConfig", + "NearCacheConfigHolder": "pubcontrol.NearCacheConfigHolder", + "WanReplicationRef": "pubcontrol.WanReplicationRef" + } } \ No newline at end of file diff --git a/tests/test_go_generator.py b/tests/test_go_generator.py new file mode 100644 index 000000000..31f6c77b2 --- /dev/null +++ b/tests/test_go_generator.py @@ -0,0 +1,113 @@ +import unittest +from collections import namedtuple + +from go.generator import merge_dict + + +class GoGeneratorTestCase(unittest.TestCase): + + def test_merge_dict(self): + case = namedtuple("case", ["msg", "a", "b", "target"]) + test_cases = [ + # case( + # msg="a and b are empty", + # a={}, + # b={}, + # target={}, + # ), + # case( + # msg="only a is empty", + # a={}, + # b={"k1": "v1"}, + # target={"k1": "v1"}, + # ), + # case( + # msg="only b is empty", + # a={"k1": "v1"}, + # b={}, + # target={"k1": "v1"}, + # ), + # case( + # msg="both a and b are simple dicts", + # a={"ka1": "va1", "k1": "v1"}, + # b={"kb1": "vb1", "k1": "v2"}, + # target={"ka1": "va1", "kb1": "vb1", "k1": "v2"} + # ), + # case( + # msg="a is nested dict, b is simple dict", + # a={"ka1": "va1", "k1": {"ka21", "va21"}}, + # b={"kb1": "vb1", "k1": "v2"}, + # target={"ka1": "va1", "kb1": "vb1", "k1": "v2"} + # ), + # case( + # msg="a is simple dict, b is nested dict", + # a={"ka1": "va1", "k1": "v1"}, + # b={"kb1": "vb1", "k1": {"kb21", "vb21"}}, + # target={"ka1": "va1", "kb1": "vb1", "k1": {"kb21", "vb21"}} + # ), + # case( + # msg="both a and be are non-overlapping nested dicts", + # a={"ka1": "va1", "ka2": {"ka21", "va21"}, "k1": "v1"}, + # b={"kb1": "vb1", "kb2": {"kb21", "vb21"}, "k1": "v1"}, + # target={"ka1": "va1", "ka2": {"ka21", "va21"}, "kb2": {"kb21", "vb21"}, "kb1": "vb1", "k1": "v1"} + # ), + case( + msg="both a and be are overlapping nested dicts", + a={"k2": {"k21": "va21", "ka21": "va21"}}, + b={"k2": {"k21": "vb21", "kb21": "vb21"}}, + target={"k2": {"k21": "vb21", "ka21": "va21", "kb21": "vb21"}} + ), + case( + msg="", + a={ + "builtin": [ + "ByteArrayCodec", "CodecUtil", "DataCodec", + ], + "public": { + "cluster": ["Address", "EndpointQualifier", "MemberInfo", "MemberVersion"], + "sql": ["ListSqlColumnMetadata", "SqlColumnMetadata"], + "types": [ + "BitmapIndexOptions", "DistributedObjectInfo", "IndexConfig", + "SimpleEntryView", "UUID" + ], + }, + "internal": { + "hzerrors": ["StackTraceElement"], + "serialization": ["Data"], + "sql": ["Error", "Page", "QueryID"] + } + }, + b={ + "public": { + "control": ["EventJournalConfig"] + } + }, + target={ + "builtin": [ + "ByteArrayCodec", "CodecUtil", "DataCodec", + ], + "public": { + "cluster": ["Address", "EndpointQualifier", "MemberInfo", "MemberVersion"], + "control": ["EventJournalConfig"], + "sql": ["ListSqlColumnMetadata", "SqlColumnMetadata"], + "types": [ + "BitmapIndexOptions", "DistributedObjectInfo", "IndexConfig", + "SimpleEntryView", "UUID" + ], + }, + "internal": { + "hzerrors": ["StackTraceElement"], + "serialization": ["Data"], + "sql": ["Error", "Page", "QueryID"] + } + } + ) + ] + for case in test_cases: + with self.subTest(msg=case.msg): + merge_dict(case.a, case.b) + self.assertEqual(case.a, case.target) + + +if __name__ == '__main__': + unittest.main() diff --git a/util.py b/util.py index 5876c2c4f..06f6ded14 100644 --- a/util.py +++ b/util.py @@ -618,10 +618,5 @@ def create_environment(lang, namespace): env.globals["custom_type_name"] = language_specific_funcs["custom_type_name"][lang] env.globals["get_size"] = get_size env.globals["is_trivial"] = is_trivial - env.globals["get_import_path_holders"] = language_specific_funcs["get_import_path_holders"][ - lang - ] - env.globals["augment_enum"] = language_specific_funcs["augment_enum"].get(lang) - env.globals["rename_field"] = language_specific_funcs["rename_field"].get(lang) return env From 3792b43863de57f39f0138c50655e346b6996d63 Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Thu, 7 Apr 2022 12:12:22 +0300 Subject: [PATCH 28/41] Updates --- go/custom-codec-template.j2 | 6 ++-- go/generator.py | 56 +++++++++++++++++++++++++++++++------ 2 files changed, 50 insertions(+), 12 deletions(-) diff --git a/go/custom-codec-template.j2 b/go/custom-codec-template.j2 index 02439f922..5f9683b8c 100644 --- a/go/custom-codec-template.j2 +++ b/go/custom-codec-template.j2 @@ -134,9 +134,9 @@ func Decode{{ codec.name|capital }}(frameIterator *proto.ForwardFrameIterator) { initialFrame := frameIterator.Next() {% endif %} {% if param in fix_sized_new_params %} - let {{ escape_keyword(param.name) }} = {% if param.type == 'boolean' %}false{% elif param.type == 'UUID' %}null{% else %}0{% endif %} - if (initialFrame.content.length >= {{ to_upper_snake_case(param.name) }}_OFFSET + BitsUtil.{{ param.type.upper() }}_SIZE_IN_BYTES) { - {{ escape_keyword(param.name) }} = Decode{{ param.type|capital }}(initialFrame.Content, {{ to_upper_snake_case(param.name) }}_OFFSET) + var {{ escape_keyword(param.name) }} {{ lang_types_encode(param.type) }} + if len(initialFrame.Content) >= {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset + proto.{{ param.type|capitalize }}SizeInBytes { + {{ escape_keyword(param.name) }} = Decode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset) } {% else %} {{ escape_keyword(param.name) }} := Decode{{ param.type|capital }}(initialFrame.Content, {{ codec.name|capital }}Codec{{ param.name|capital }}FieldOffset) diff --git a/go/generator.py b/go/generator.py index 9fe9b0aae..ecf1891ea 100644 --- a/go/generator.py +++ b/go/generator.py @@ -2,20 +2,25 @@ import json import os import fnmatch +import re from datetime import datetime from jinja2 import Environment, PackageLoader from cpp import get_size, is_trivial -from util import _snake_cased_name_generator, capital, to_upper_snake_case, is_var_sized_list_contains_nullable, \ +from py import py_param_name +from util import capital, to_upper_snake_case, is_var_sized_list_contains_nullable, \ fixed_params, var_size_params, new_params, filter_new_params, is_var_sized_list, is_var_sized_entry_list, \ is_var_sized_map, item_type, key_type, value_type, param_name, java_name from .config import Config +RE_PKG_TYPE = re.compile(r"([a-z]+)\.(\w+)") + + class GoGenerator: - filename_gen = _snake_cased_name_generator("go") + codec_filename_gen = lambda *names: f'{"_".join(map(py_param_name, names))}_codec.go' def __init__(self, services, custom_protocol, output_dir, args): self.services = services @@ -40,6 +45,7 @@ def __init__(self, services, custom_protocol, output_dir, args): def generate(self): for service in self.services: self.generate_service(service) + self.generate_type_codecs(self.custom_types) self.generate_types(self.custom_types) def generate_service(self, service): @@ -59,7 +65,7 @@ def generate_method(self, service, method, template): method["response"]["id"] = self.make_id(service["id"], method["id"], 1) for i, event in enumerate(method.get("events", [])): event["id"] = self.make_id(service["id"], method["id"], i + 2) - codec_file_name = GoGenerator.filename_gen(service["name"], method["name"]) + codec_file_name = GoGenerator.codec_filename_gen(service["name"], method["name"]) try: content = template.render(service_name=service["name"], method=method, **opts) path = os.path.join(self.output_dir, codec_file_name) @@ -67,19 +73,50 @@ def generate_method(self, service, method, template): except NotImplementedError as e: print(f"{codec_file_name} contains missing type mapping so ignoring it. Error: {e}") - def generate_types(self, codecs): + def generate_type_codecs(self, codecs): template = self.env.get_template("custom-codec-template.j2") for codec in codecs: - self.generate_type(codec, template) + self.generate_type_codec(codec, template) - def generate_type(self, codec, template): + def generate_type_codec(self, codec, template): if not self.can_generate_type(codec["name"]): return opts = {"base_import_path": self.config.base_import_path} - codec_file_name = GoGenerator.filename_gen(codec["name"]) - print("Custom:", codec_file_name) + fname = GoGenerator.codec_filename_gen(codec["name"]) content = template.render(codec=codec, **opts) - path = os.path.join(self.output_dir, codec_file_name) + path = os.path.join(self.output_dir, fname) + self.save(path, content) + + def generate_types(self, codecs): + template = self.env.get_template("type-template.j2") + for codec in codecs: + self.generate_type(codec, template) + + def generate_type(self, codec, template): + codec_name = codec["name"] + if not self.can_generate_type(codec_name): + return + to_t = self.mapping.get(codec_name) + if not to_t: + print(f"Mapping for type {codec_name} not found") + return + pkg_t = RE_PKG_TYPE.search(to_t) + if not pkg_t: + print(f"Not a custom type: {to_t}") + return + pkg, t = pkg_t.group(1), pkg_t.group(2) + path = "" + if pkg.startswith("pub"): + pkg = pkg[3:] + path = pkg + elif pkg.startswith("i"): + pkg = pkg[1:] + path = f"internal/{pkg}" + path = os.path.join(self.output_dir, path) + os.makedirs(path, exist_ok=True) + fname = f'{py_param_name(codec_name)}.go' + content = template.render(codec=codec, package_name=pkg) + path = os.path.join(path, fname) self.save(path, content) def can_generate_method(self, method_name: str) -> bool: @@ -313,6 +350,7 @@ def merge_dict(d1, d2: dict): DEFAULT_MAPPING = { + "Address": "", "boolean": "bool", "byte": "byte", "EntryList_Data_Data": "[]proto.Pair", From 8ed24975b50ae9f829a491c86ec76e6a4f1323ae Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Thu, 7 Apr 2022 12:26:23 +0300 Subject: [PATCH 29/41] Updates --- tests/fixtures/hzpo-config.json | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/tests/fixtures/hzpo-config.json b/tests/fixtures/hzpo-config.json index 5cd347451..cd2299f89 100644 --- a/tests/fixtures/hzpo-config.json +++ b/tests/fixtures/hzpo-config.json @@ -1,13 +1,14 @@ { - "base_import_path": "github.com/yuce/hazelcast-go-client-extensibility-sample", - "include_methods": ["Map.getAll", "DynamicConfig.addMapConfig"], - "include_types": ["EventJournalConfig"], + "base_import_path": "github.com/yuce/hazelcast-operator", + "include_methods": ["MC.getTimedMemberState", "Map.*"], + "include_types": ["Address", "EventJournalConfig"], "types": { "public": { - "control": ["EventJournalConfig"] + "control": ["EventJournalConfig", "Address"] } }, "mapping": { + "Address": "pubcontrol.Adddress", "EventJournalConfig": "pubcontrol.EventJournalConfig", "HotRestartConfig": "pubcontrol.HotRestartConfig", "EvictionConfigHolder": "pubcontrol.EvictionConfigHolder", From 745fc57063b76aff85cee1c0e0ae1f30bd2fb5bc Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Mon, 11 Apr 2022 17:41:07 +0300 Subject: [PATCH 30/41] Added missing type template --- go/type-template.j2 | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 go/type-template.j2 diff --git a/go/type-template.j2 b/go/type-template.j2 new file mode 100644 index 000000000..c1c9595d3 --- /dev/null +++ b/go/type-template.j2 @@ -0,0 +1,23 @@ +/* +* Copyright (c) 2008-{{ copyright_year }}, Hazelcast, Inc. All Rights Reserved. +* +* Licensed under the Apache License, Version 2.0 (the "License") +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +package {{ package_name }} + +type {{ codec.name }} struct { +{% for param in codec.params %} + {{ escape_keyword(param.name)|capital }} {{ lang_types_encode(param.type) }} +{% endfor -%} +} \ No newline at end of file From 485f123376015cf3cea2ec719ed6c38f02a944ab Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Mon, 11 Apr 2022 18:00:02 +0300 Subject: [PATCH 31/41] codec fix --- go/codec-template.j2 | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/go/codec-template.j2 b/go/codec-template.j2 index ed2310033..e5df31180 100644 --- a/go/codec-template.j2 +++ b/go/codec-template.j2 @@ -160,7 +160,7 @@ func Decode{{ service_name|capital }}{{ method.name|capital }}Response(clientMes {% endfor %} } {% else %} -func Decode{{ service_name|capital }}{{ method.name|capital }}Response(clientMessage *proto.ClientMessage) ({% for param in method.response.params %}{{ escape_keyword(param.name)}} {{ lang_types_encode(param.type) }}{{ ", " if not loop.last }}{% endfor %}{% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists: boolean;{% endfor %}) { +func Decode{{ service_name|capital }}{{ method.name|capital }}Response(clientMessage *proto.ClientMessage) ({% for param in method.response.params %}{{ escape_keyword(param.name)}} {{ lang_types_encode(param.type) }}{{ ", " if not loop.last }}{% endfor %}{% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists boolean{% endfor %}) { {% if response_fix_sized_params|length != 0 %} frameIterator := clientMessage.FrameIterator() initialFrame := frameIterator.Next() @@ -194,7 +194,7 @@ func Decode{{ service_name|capital }}{{ method.name|capital }}Response(clientMes {% endif %} {% endfor %} - return {% for param in method.response.params %}{{ escape_keyword(param.name)}}{{ ", " if not loop.last }}{% endfor %} {% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists: boolean;{% endfor %} + return {% for param in method.response.params %}{{ escape_keyword(param.name)}}{{ ", " if not loop.last }}{% endfor %} {% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists boolean{% endfor %} } {% endif %} {# EVENTS#} From d025e6767935c2ce73cfc40618c2bb01b8851100 Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Tue, 12 Apr 2022 09:21:52 +0300 Subject: [PATCH 32/41] codec fix --- go/codec-template.j2 | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/go/codec-template.j2 b/go/codec-template.j2 index e5df31180..c522f11bf 100644 --- a/go/codec-template.j2 +++ b/go/codec-template.j2 @@ -160,7 +160,7 @@ func Decode{{ service_name|capital }}{{ method.name|capital }}Response(clientMes {% endfor %} } {% else %} -func Decode{{ service_name|capital }}{{ method.name|capital }}Response(clientMessage *proto.ClientMessage) ({% for param in method.response.params %}{{ escape_keyword(param.name)}} {{ lang_types_encode(param.type) }}{{ ", " if not loop.last }}{% endfor %}{% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists boolean{% endfor %}) { +func Decode{{ service_name|capital }}{{ method.name|capital }}Response(clientMessage *proto.ClientMessage) ({% for param in method.response.params %}{{ escape_keyword(param.name)}} {{ lang_types_encode(param.type) }}{{ ", " if not loop.last }}{% endfor %}{% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists bool{% endfor %}) { {% if response_fix_sized_params|length != 0 %} frameIterator := clientMessage.FrameIterator() initialFrame := frameIterator.Next() @@ -194,7 +194,7 @@ func Decode{{ service_name|capital }}{{ method.name|capital }}Response(clientMes {% endif %} {% endfor %} - return {% for param in method.response.params %}{{ escape_keyword(param.name)}}{{ ", " if not loop.last }}{% endfor %} {% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists boolean{% endfor %} + return {% for param in method.response.params %}{{ escape_keyword(param.name)}}{{ ", " if not loop.last }}{% endfor %} {% for new_param in response_new_params %} is{{ new_param.name|capital }}Exists bool{% endfor %} } {% endif %} {# EVENTS#} From 3f24cfd3fcece098ce0496e7f96b946d3d5885b1 Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Wed, 20 Jul 2022 12:47:05 +0300 Subject: [PATCH 33/41] trivial --- go/config.json | 13 +++++++++++-- go/tests/__init__.py | 0 {tests => go/tests}/test_go_generator.py | 0 .../fixtures => go/tests/testdata}/hzpo-config.json | 12 +++++++----- 4 files changed, 18 insertions(+), 7 deletions(-) create mode 100644 go/tests/__init__.py rename {tests => go/tests}/test_go_generator.py (100%) rename {tests/fixtures => go/tests/testdata}/hzpo-config.json (62%) diff --git a/go/config.json b/go/config.json index ea35fa1ed..8b3d72426 100644 --- a/go/config.json +++ b/go/config.json @@ -1,4 +1,13 @@ { - "include_methods": ["SQL.*"], - "include_types": ["Address"] + "include_methods": ["Map.*"], + "include_types": ["Address"], + "mapping": { + "Address": "pubcluster.Address", + "longArray": "[]int64", + "List_String": "[]string", + "List_UUID": "[]types.UUID", + "List_Long": "[]int64", + "EntryList_String_EntryList_Integer_Long": "map[string]map[int32]int64", + "EntryList_Integer_UUID": "map[int32]types.UUID" + } } \ No newline at end of file diff --git a/go/tests/__init__.py b/go/tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/test_go_generator.py b/go/tests/test_go_generator.py similarity index 100% rename from tests/test_go_generator.py rename to go/tests/test_go_generator.py diff --git a/tests/fixtures/hzpo-config.json b/go/tests/testdata/hzpo-config.json similarity index 62% rename from tests/fixtures/hzpo-config.json rename to go/tests/testdata/hzpo-config.json index cd2299f89..6fbfd33ef 100644 --- a/tests/fixtures/hzpo-config.json +++ b/go/tests/testdata/hzpo-config.json @@ -1,10 +1,10 @@ { - "base_import_path": "github.com/yuce/hazelcast-operator", - "include_methods": ["MC.getTimedMemberState", "Map.*"], - "include_types": ["Address", "EventJournalConfig"], + "base_import_path": "github.com/yuce/listindexes", + "include_methods": ["MC.getMapConfig"], + "include_types": ["Address", "EventJournalConfig", "IndexConfig"], "types": { "public": { - "control": ["EventJournalConfig", "Address"] + "control": ["EventJournalConfig", "Address", "IndexConfig"] } }, "mapping": { @@ -17,6 +17,8 @@ "MapStoreConfigHolder": "pubcontrol.MapStoreConfigHolder", "MerkleTreeConfig": "pubcontrol.MerkleTreeConfig", "NearCacheConfigHolder": "pubcontrol.NearCacheConfigHolder", - "WanReplicationRef": "pubcontrol.WanReplicationRef" + "WanReplicationRef": "pubcontrol.WanReplicationRef", + "List_String": "[]string", + "IndexConfig": "pubtypes.IndexConfig" } } \ No newline at end of file From 0ce9c1e7afb07a7eb53bf92034df7eb596fb5c97 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Or=C3=A7un=20=C3=87olak?= Date: Tue, 13 Dec 2022 11:10:20 +0300 Subject: [PATCH 34/41] Jet job submission from non-java client [HZ-1455] Added two new messages for job submissions --- protocol-definitions/Jet.yaml | 85 +++++++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) diff --git a/protocol-definitions/Jet.yaml b/protocol-definitions/Jet.yaml index a7181bfb1..3cfb02a10 100644 --- a/protocol-definitions/Jet.yaml +++ b/protocol-definitions/Jet.yaml @@ -301,3 +301,88 @@ methods: nullable: false since: 2.5 doc: '' + - id: 16 + name: uploadJobMetaData + since: 2.6 + doc: '' + request: + retryable: true + partitionIdentifier: -1 + params: + - name: sessionId + type: UUID + nullable: false + since: 2.6 + doc: 'Unique session ID of the job upload request' + - name: jarSize + type: long + nullable: false + since: 2.6 + doc: 'jar size in bytes' + - name: snapshotName + type: String + nullable: true + since: 2.6 + doc: 'Name of the initial snapshot to start the job from' + - name: jobName + type: String + nullable: true + since: 2.6 + doc: 'Name of the job' + - name: mainClass + type: String + nullable: true + since: 2.6 + doc: 'Fully qualified name of the main class inside the JAR file' + - name: jobParameters + type: List_String + nullable: false + since: 2.6 + doc: 'Arguments to pass to the supplied jar file' + response: + params: + - name: response + type: boolean + nullable: false + since: 2.6 + doc: 'True if processed successfully, false otherwise' + - id: 17 + name: uploadJobData + since: 2.6 + doc: '' + request: + retryable: true + partitionIdentifier: -1 + params: + - name: sessionId + type: UUID + nullable: false + since: 2.6 + doc: 'Unique session ID of the job upload request' + - name: currentPartNumber + type: int + nullable: false + since: 2.6 + doc: 'The current part number being sent. Starts from 1' + - name: totalPartNumber + type: int + nullable: false + since: 2.6 + doc: 'The total number of parts to be sent. Minimum value is 1' + - name: partData + type: byteArray + nullable: false + since: 2.6 + doc: 'The binary data of the message part' + - name: partSize + type: int + nullable: false + since: 2.6 + doc: 'The size of binary data' + response: + params: + - name: response + type: boolean + nullable: false + since: 2.6 + doc: 'True if processed successfully, false otherwise' \ No newline at end of file From bfcba282934750bfdee32e9735c1e58d6acf57c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Or=C3=A7un=20=C3=87olak?= Date: Fri, 16 Dec 2022 10:47:42 +0300 Subject: [PATCH 35/41] Jet job submission from non-java client [HZ-1455] Added two new messages for job submissions --- protocol-definitions/Jet.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/protocol-definitions/Jet.yaml b/protocol-definitions/Jet.yaml index 3cfb02a10..700ba24b1 100644 --- a/protocol-definitions/Jet.yaml +++ b/protocol-definitions/Jet.yaml @@ -347,7 +347,7 @@ methods: since: 2.6 doc: 'True if processed successfully, false otherwise' - id: 17 - name: uploadJobData + name: uploadJobMultipart since: 2.6 doc: '' request: From 211ffe6edb818b7fd4102b53565b0a46f89ffb3c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Or=C3=A7un=20=C3=87olak?= Date: Tue, 20 Dec 2022 16:13:08 +0300 Subject: [PATCH 36/41] Jet job submission from non-java client [HZ-1455] Added two new messages for job submissions Added a new field for checksum --- protocol-definitions/Jet.yaml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/protocol-definitions/Jet.yaml b/protocol-definitions/Jet.yaml index 700ba24b1..4200b319c 100644 --- a/protocol-definitions/Jet.yaml +++ b/protocol-definitions/Jet.yaml @@ -314,6 +314,11 @@ methods: nullable: false since: 2.6 doc: 'Unique session ID of the job upload request' + - name: md5Hex + type: String + nullable: false + since: 2.6 + doc: 'Hexadecimal MD5 of the jar file' - name: jarSize type: long nullable: false From 68831d8724d1993e2b0580f69a1da630773fa601 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Or=C3=A7un=20=C3=87olak?= Date: Wed, 21 Dec 2022 14:12:37 +0300 Subject: [PATCH 37/41] Jet job submission from non-java client [HZ-1455] Added two new messages for job submissions Added a new field for checksum --- protocol-definitions/Jet.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/protocol-definitions/Jet.yaml b/protocol-definitions/Jet.yaml index 4200b319c..04b83fedc 100644 --- a/protocol-definitions/Jet.yaml +++ b/protocol-definitions/Jet.yaml @@ -314,11 +314,11 @@ methods: nullable: false since: 2.6 doc: 'Unique session ID of the job upload request' - - name: md5Hex + - name: sha256Hex type: String nullable: false since: 2.6 - doc: 'Hexadecimal MD5 of the jar file' + doc: 'Hexadecimal SHA256 of the jar file' - name: jarSize type: long nullable: false From 219374035ab455a8be97a8d257e13489f1cab258 Mon Sep 17 00:00:00 2001 From: orcuncolak Date: Tue, 10 Jan 2023 11:42:03 +0300 Subject: [PATCH 38/41] Jet job submission from non-java client [HZ-1455] --- protocol-definitions/Jet.yaml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/protocol-definitions/Jet.yaml b/protocol-definitions/Jet.yaml index 04b83fedc..79349150c 100644 --- a/protocol-definitions/Jet.yaml +++ b/protocol-definitions/Jet.yaml @@ -314,6 +314,11 @@ methods: nullable: false since: 2.6 doc: 'Unique session ID of the job upload request' + - name: fileName + type: String + nullable: false + since: 2.6 + doc: 'Name of the jar file without extension' - name: sha256Hex type: String nullable: false From 4ded848eff6513dd1dbe9b84fc181bb0c801f77f Mon Sep 17 00:00:00 2001 From: orcuncolak Date: Tue, 10 Jan 2023 12:24:29 +0300 Subject: [PATCH 39/41] Jet job submission from non-java client [HZ-1455] --- protocol-definitions/Jet.yaml | 5 ----- 1 file changed, 5 deletions(-) diff --git a/protocol-definitions/Jet.yaml b/protocol-definitions/Jet.yaml index 79349150c..0b6b92c65 100644 --- a/protocol-definitions/Jet.yaml +++ b/protocol-definitions/Jet.yaml @@ -324,11 +324,6 @@ methods: nullable: false since: 2.6 doc: 'Hexadecimal SHA256 of the jar file' - - name: jarSize - type: long - nullable: false - since: 2.6 - doc: 'jar size in bytes' - name: snapshotName type: String nullable: true From 519eb00d4581e2f0ea52a2738211ca9a280b19ec Mon Sep 17 00:00:00 2001 From: orcuncolak Date: Tue, 10 Jan 2023 17:02:30 +0300 Subject: [PATCH 40/41] Jet job submission from non-java client [HZ-1455] --- protocol-definitions/Jet.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/protocol-definitions/Jet.yaml b/protocol-definitions/Jet.yaml index 0b6b92c65..1b31772a4 100644 --- a/protocol-definitions/Jet.yaml +++ b/protocol-definitions/Jet.yaml @@ -390,4 +390,4 @@ methods: type: boolean nullable: false since: 2.6 - doc: 'True if processed successfully, false otherwise' \ No newline at end of file + doc: 'True if processed successfully, false otherwise' From e542cd251906e0bf6c8d4a3711b510f6acb748b3 Mon Sep 17 00:00:00 2001 From: Yuce Tekol Date: Mon, 12 Aug 2024 11:54:22 +0300 Subject: [PATCH 41/41] Added setuptools as a dependency --- requirements.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 36158e3f3..873495aa8 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,4 @@ PyYAML jsonschema -jinja2 \ No newline at end of file +jinja2 +setuptools==72.1.0 \ No newline at end of file