This is an automated email from the ASF dual-hosted git repository.
sergeychugunov pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ignite.git
The following commit(s) were added to refs/heads/master by this push:
new e74bb482111 IGNITE-25968 Use MessageSerializer for FragmentDescription
(#12204)
e74bb482111 is described below
commit e74bb482111a7d479f5439e908c89f3fb2e59918
Author: Maksim Davydov <[email protected]>
AuthorDate: Mon Sep 1 12:00:52 2025 +0300
IGNITE-25968 Use MessageSerializer for FragmentDescription (#12204)
---
modules/calcite/pom.xml | 6 +
.../calcite/message/CalciteMessageFactory.java | 9 +-
.../query/calcite/message/MessageType.java | 26 +-
.../calcite/metadata/FragmentDescription.java | 122 ++-----
.../internal/MessageSerializerGenerator.java | 23 ++
.../org/apache/ignite/internal/GridDirectMap.java | 3 +
.../extensions/communication/MessageReader.java | 1 +
.../internal/codegen/MessageProcessorTest.java | 14 +
.../src/test/resources/codegen/TestMapMessage.java | 278 +++++++++++++++
.../codegen/TestMapMessageSerializer.java | 373 +++++++++++++++++++++
10 files changed, 760 insertions(+), 95 deletions(-)
diff --git a/modules/calcite/pom.xml b/modules/calcite/pom.xml
index a90c1ffc3c5..366ca77711e 100644
--- a/modules/calcite/pom.xml
+++ b/modules/calcite/pom.xml
@@ -72,6 +72,12 @@
<version>${calcite.version}</version>
</dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>ignite-codegen2</artifactId>
+ <scope>provided</scope>
+ </dependency>
+
<dependency>
<groupId>org.apache.calcite</groupId>
<artifactId>calcite-linq4j</artifactId>
diff --git
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/message/CalciteMessageFactory.java
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/message/CalciteMessageFactory.java
index 687d38c3e06..f78b7e39959 100644
---
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/message/CalciteMessageFactory.java
+++
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/message/CalciteMessageFactory.java
@@ -28,8 +28,13 @@ public class CalciteMessageFactory implements
MessageFactoryProvider {
/** {@inheritDoc} */
@SuppressWarnings({"unchecked", "rawtypes"})
@Override public void registerAll(MessageFactory factory) {
- for (MessageType type : MessageType.values())
- factory.register(type.directType(), (Supplier)type.factory());
+ for (MessageType type : MessageType.values()) {
+ // TODO: Temporary check — remove once all inheritors have
migrated to the new serialization framework
+ if (type.serializer() != null)
+ factory.register(type.directType(), (Supplier)type.factory(),
type.serializer());
+ else
+ factory.register(type.directType(), (Supplier)type.factory());
+ }
}
/**
diff --git
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/message/MessageType.java
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/message/MessageType.java
index 56b57c385c7..9492d66d650 100644
---
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/message/MessageType.java
+++
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/message/MessageType.java
@@ -18,9 +18,11 @@
package org.apache.ignite.internal.processors.query.calcite.message;
import java.util.function.Supplier;
+import org.apache.ignite.internal.codegen.FragmentDescriptionSerializer;
import
org.apache.ignite.internal.processors.query.calcite.metadata.ColocationGroup;
import
org.apache.ignite.internal.processors.query.calcite.metadata.FragmentDescription;
import
org.apache.ignite.internal.processors.query.calcite.metadata.FragmentMapping;
+import org.apache.ignite.plugin.extensions.communication.MessageSerializer;
/**
*
@@ -57,7 +59,7 @@ public enum MessageType {
COLOCATION_GROUP(351, ColocationGroup::new),
/** */
- FRAGMENT_DESCRIPTION(352, FragmentDescription::new),
+ FRAGMENT_DESCRIPTION(352, FragmentDescription::new, new
FragmentDescriptionSerializer()),
/** */
QUERY_TX_ENTRY(353, QueryTxEntry::new);
@@ -68,14 +70,29 @@ public enum MessageType {
/** */
private final Supplier<CalciteMessage> factory;
+ /** */
+ private MessageSerializer serializer;
+
/**
* @param directType Message direct type.
+ * @param factory Message factory.
*/
MessageType(int directType, Supplier<CalciteMessage> factory) {
this.directType = directType;
this.factory = factory;
}
+ /**
+ * @param directType Message direct type.
+ * @param factory Message factory.
+ * @param serializer Message serializer.
+ */
+ MessageType(int directType, Supplier<CalciteMessage> factory,
MessageSerializer serializer) {
+ this.directType = directType;
+ this.factory = factory;
+ this.serializer = serializer;
+ }
+
/**
* @return Message direct type;
*/
@@ -89,4 +106,11 @@ public enum MessageType {
public Supplier<CalciteMessage> factory() {
return factory;
}
+
+ /**
+ * @return Message serializer.
+ */
+ public MessageSerializer serializer() {
+ return serializer;
+ }
}
diff --git
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/metadata/FragmentDescription.java
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/metadata/FragmentDescription.java
index fdb5a39578f..47d6b63b751 100644
---
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/metadata/FragmentDescription.java
+++
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/metadata/FragmentDescription.java
@@ -17,41 +17,37 @@
package org.apache.ignite.internal.processors.query.calcite.metadata;
-import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
-import org.apache.ignite.internal.GridDirectMap;
-import org.apache.ignite.internal.GridDirectTransient;
+import org.apache.ignite.internal.Order;
import org.apache.ignite.internal.processors.cache.GridCacheSharedContext;
import
org.apache.ignite.internal.processors.query.calcite.message.MarshalableMessage;
import org.apache.ignite.internal.processors.query.calcite.message.MessageType;
import org.apache.ignite.internal.util.UUIDCollectionMessage;
import org.apache.ignite.internal.util.typedef.internal.U;
-import org.apache.ignite.plugin.extensions.communication.Message;
-import
org.apache.ignite.plugin.extensions.communication.MessageCollectionItemType;
-import org.apache.ignite.plugin.extensions.communication.MessageReader;
-import org.apache.ignite.plugin.extensions.communication.MessageWriter;
/** */
public class FragmentDescription implements MarshalableMessage {
/** */
+ @Order(0)
private long fragmentId;
/** */
+ @Order(1)
private FragmentMapping mapping;
/** */
- private ColocationGroup target;
+ @Order(2) // TODO: Remove this field (and MarshallableMessage interface)
once IGNITE-26133 is completed
+ private Map<Long, UUIDCollectionMessage> remoteSources0;
/** */
- @GridDirectTransient
- private Map<Long, List<UUID>> remoteSources;
+ @Order(3)
+ private ColocationGroup target;
/** */
- @GridDirectMap(keyType = Long.class, valueType = Message.class)
- private Map<Long, UUIDCollectionMessage> remoteSources0;
+ private Map<Long, List<UUID>> remoteSources;
/** */
public FragmentDescription() {
@@ -71,6 +67,11 @@ public class FragmentDescription implements
MarshalableMessage {
return fragmentId;
}
+ /** */
+ public void fragmentId(long fragmentId) {
+ this.fragmentId = fragmentId;
+ }
+
/** */
public List<UUID> nodeIds() {
return mapping.nodeIds();
@@ -81,6 +82,11 @@ public class FragmentDescription implements
MarshalableMessage {
return target;
}
+ /** */
+ public void target(ColocationGroup target) {
+ this.target = target;
+ }
+
/** */
public Map<Long, List<UUID>> remotes() {
return remoteSources;
@@ -91,92 +97,24 @@ public class FragmentDescription implements
MarshalableMessage {
return mapping;
}
- /** {@inheritDoc} */
- @Override public MessageType type() {
- return MessageType.FRAGMENT_DESCRIPTION;
+ /** */
+ public void mapping(FragmentMapping mapping) {
+ this.mapping = mapping;
}
- /** {@inheritDoc} */
- @Override public boolean writeTo(ByteBuffer buf, MessageWriter writer) {
- writer.setBuffer(buf);
-
- if (!writer.isHeaderWritten()) {
- if (!writer.writeHeader(directType()))
- return false;
-
- writer.onHeaderWritten();
- }
-
- switch (writer.state()) {
- case 0:
- if (!writer.writeLong(fragmentId))
- return false;
-
- writer.incrementState();
-
- case 1:
- if (!writer.writeMessage(mapping))
- return false;
-
- writer.incrementState();
-
- case 2:
- if (!writer.writeMap(remoteSources0,
MessageCollectionItemType.LONG, MessageCollectionItemType.MSG))
- return false;
-
- writer.incrementState();
-
- case 3:
- if (!writer.writeMessage(target))
- return false;
-
- writer.incrementState();
-
- }
+ /** */
+ public Map<Long, UUIDCollectionMessage> remoteSources0() {
+ return remoteSources0;
+ }
- return true;
+ /** */
+ public void remoteSources0(Map<Long, UUIDCollectionMessage>
remoteSources0) {
+ this.remoteSources0 = remoteSources0;
}
/** {@inheritDoc} */
- @Override public boolean readFrom(ByteBuffer buf, MessageReader reader) {
- reader.setBuffer(buf);
-
- switch (reader.state()) {
- case 0:
- fragmentId = reader.readLong();
-
- if (!reader.isLastRead())
- return false;
-
- reader.incrementState();
-
- case 1:
- mapping = reader.readMessage();
-
- if (!reader.isLastRead())
- return false;
-
- reader.incrementState();
-
- case 2:
- remoteSources0 =
reader.readMap(MessageCollectionItemType.LONG, MessageCollectionItemType.MSG,
false);
-
- if (!reader.isLastRead())
- return false;
-
- reader.incrementState();
-
- case 3:
- target = reader.readMessage();
-
- if (!reader.isLastRead())
- return false;
-
- reader.incrementState();
-
- }
-
- return true;
+ @Override public MessageType type() {
+ return MessageType.FRAGMENT_DESCRIPTION;
}
/** {@inheritDoc} */
diff --git
a/modules/codegen2/src/main/java/org/apache/ignite/internal/MessageSerializerGenerator.java
b/modules/codegen2/src/main/java/org/apache/ignite/internal/MessageSerializerGenerator.java
index 930bbcf9ee3..1e26d38c451 100644
---
a/modules/codegen2/src/main/java/org/apache/ignite/internal/MessageSerializerGenerator.java
+++
b/modules/codegen2/src/main/java/org/apache/ignite/internal/MessageSerializerGenerator.java
@@ -30,6 +30,7 @@ import java.util.BitSet;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
+import java.util.Map;
import java.util.Set;
import java.util.UUID;
import javax.annotation.processing.FilerException;
@@ -351,6 +352,18 @@ class MessageSerializerGenerator {
else if (sameType(type,
"org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion"))
returnFalseIfWriteFailed(write,
"writer.writeAffinityTopologyVersion", getExpr);
+ else if (assignableFrom(erasedType(type),
type(Map.class.getName()))) {
+ List<? extends TypeMirror> typeArgs =
((DeclaredType)type).getTypeArguments();
+
+ assert typeArgs.size() == 2;
+
+
imports.add("org.apache.ignite.plugin.extensions.communication.MessageCollectionItemType");
+
+ returnFalseIfWriteFailed(write, "writer.writeMap", getExpr,
+ "MessageCollectionItemType." +
messageCollectionItemType(typeArgs.get(0)),
+ "MessageCollectionItemType." +
messageCollectionItemType(typeArgs.get(1)));
+ }
+
else if (assignableFrom(type, type(MESSAGE_INTERFACE)))
returnFalseIfWriteFailed(write, "writer.writeMessage",
getExpr);
@@ -464,6 +477,16 @@ class MessageSerializerGenerator {
else if (sameType(type,
"org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion"))
returnFalseIfReadFailed(name,
"reader.readAffinityTopologyVersion");
+ else if (assignableFrom(erasedType(type),
type(Map.class.getName()))) {
+ List<? extends TypeMirror> typeArgs =
((DeclaredType)type).getTypeArguments();
+
+ assert typeArgs.size() == 2;
+
+ returnFalseIfReadFailed(name, "reader.readMap",
+ "MessageCollectionItemType." +
messageCollectionItemType(typeArgs.get(0)),
+ "MessageCollectionItemType." +
messageCollectionItemType(typeArgs.get(1)), "false");
+ }
+
else if (assignableFrom(type, type(MESSAGE_INTERFACE)))
returnFalseIfReadFailed(name, "reader.readMessage");
diff --git
a/modules/core/src/main/java/org/apache/ignite/internal/GridDirectMap.java
b/modules/core/src/main/java/org/apache/ignite/internal/GridDirectMap.java
index de42211e1f0..8bddc4756d5 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/GridDirectMap.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/GridDirectMap.java
@@ -24,9 +24,12 @@ import java.lang.annotation.Target;
/**
* Annotates map fields.
+ * Deprecated as not needed for new messages. See {@link Order} and {@link
MessageProcessor} for details on how message
+ * serialization code is generated.
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
+@Deprecated
public @interface GridDirectMap {
/**
* @return Key type.
diff --git
a/modules/core/src/main/java/org/apache/ignite/plugin/extensions/communication/MessageReader.java
b/modules/core/src/main/java/org/apache/ignite/plugin/extensions/communication/MessageReader.java
index 868df4f397d..6d0ac9d191c 100644
---
a/modules/core/src/main/java/org/apache/ignite/plugin/extensions/communication/MessageReader.java
+++
b/modules/core/src/main/java/org/apache/ignite/plugin/extensions/communication/MessageReader.java
@@ -222,6 +222,7 @@ public interface MessageReader {
* @param <M> Type of the red map.
* @return Map.
*/
+ // TODO: IGNITE-26329 — switch to the new readMap method without the flag
parameter
public <M extends Map<?, ?>> M readMap(MessageCollectionItemType keyType,
MessageCollectionItemType valType, boolean linked);
diff --git
a/modules/core/src/test/java/org/apache/ignite/internal/codegen/MessageProcessorTest.java
b/modules/core/src/test/java/org/apache/ignite/internal/codegen/MessageProcessorTest.java
index a9d653ff3e6..f83be0324b1 100644
---
a/modules/core/src/test/java/org/apache/ignite/internal/codegen/MessageProcessorTest.java
+++
b/modules/core/src/test/java/org/apache/ignite/internal/codegen/MessageProcessorTest.java
@@ -66,6 +66,20 @@ public class MessageProcessorTest {
.hasSourceEquivalentTo(javaFile("TestCollectionsMessageSerializer.java"));
}
+ /** */
+ @Test
+ public void testMapMessage() {
+ Compilation compilation = compile("TestMapMessage.java");
+
+ assertThat(compilation).succeeded();
+
+ assertEquals(1, compilation.generatedSourceFiles().size());
+
+ assertThat(compilation)
+
.generatedSourceFile("org.apache.ignite.internal.codegen.TestMapMessageSerializer")
+ .hasSourceEquivalentTo(javaFile("TestMapMessageSerializer.java"));
+ }
+
/** */
@Test
public void testEmptyMessage() {
diff --git a/modules/core/src/test/resources/codegen/TestMapMessage.java
b/modules/core/src/test/resources/codegen/TestMapMessage.java
new file mode 100644
index 00000000000..3d81c27f297
--- /dev/null
+++ b/modules/core/src/test/resources/codegen/TestMapMessage.java
@@ -0,0 +1,278 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.ignite.internal;
+
+import java.util.BitSet;
+import java.util.Map;
+import java.util.UUID;
+import org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion;
+import org.apache.ignite.internal.processors.cache.version.GridCacheVersion;
+import org.apache.ignite.lang.IgniteUuid;
+import org.apache.ignite.plugin.extensions.communication.Message;
+
+public class TestMapMessage implements Message {
+ @Order(0)
+ private Map<boolean[], Long> booleanArrayBoxedLongMap;
+
+ @Order(1)
+ private Map<byte[], boolean[]> byteArrayBooleanArrayMap;
+
+ @Order(2)
+ private Map<short[], byte[]> shortArrayByteArrayMap;
+
+ @Order(3)
+ private Map<int[], short[]> intArrayShortArrayMap;
+
+ @Order(4)
+ private Map<long[], int[]> longArrayIntArrayMap;
+
+ @Order(5)
+ private Map<char[], long[]> charArrayLongArrayMap;
+
+ @Order(6)
+ private Map<float[], char[]> floatArrayCharArrayMap;
+
+ @Order(7)
+ private Map<double[], float[]> doubleArrayFloatArrayMap;
+
+ @Order(8)
+ private Map<String, double[]> stringDoubleArrayMap;
+
+ @Order(9)
+ private Map<UUID, String> uuidStringMap;
+
+ @Order(10)
+ private Map<BitSet, UUID> bitSetUuidMap;
+
+ @Order(11)
+ private Map<IgniteUuid, BitSet> igniteUuidBitSetMap;
+
+ @Order(12)
+ private Map<AffinityTopologyVersion, IgniteUuid>
affTopVersionIgniteUuidMap;
+
+ @Order(13)
+ private Map<Boolean, AffinityTopologyVersion> boxedBooleanAffTopVersionMap;
+
+ @Order(14)
+ private Map<Byte, Boolean> boxedByteBoxedBooleanMap;
+
+ @Order(15)
+ private Map<Short, Byte> boxedShortBoxedByteMap;
+
+ @Order(16)
+ private Map<Integer, Short> boxedIntBoxedShortMap;
+
+ @Order(17)
+ private Map<Long, Integer> boxedLongBoxedIntMap;
+
+ @Order(18)
+ private Map<Character, Long> boxedCharBoxedLongMap;
+
+ @Order(19)
+ private Map<Float, Character> boxedFloatBoxedCharMap;
+
+ @Order(20)
+ private Map<Double, Float> boxedDoubleBoxedFloatMap;
+
+ @Order(21)
+ private Map<GridCacheVersion, Double> messageBoxedDoubleMap;
+
+ public Map<boolean[], Long> booleanArrayBoxedLongMap() {
+ return booleanArrayBoxedLongMap;
+ }
+
+ public void booleanArrayBoxedLongMap(Map<boolean[], Long>
booleanArrayBoxedLongMap) {
+ this.booleanArrayBoxedLongMap = booleanArrayBoxedLongMap;
+ }
+
+ public Map<byte[], boolean[]> byteArrayBooleanArrayMap() {
+ return byteArrayBooleanArrayMap;
+ }
+
+ public void byteArrayBooleanArrayMap(Map<byte[], boolean[]>
byteArrayBooleanArrayMap) {
+ this.byteArrayBooleanArrayMap = byteArrayBooleanArrayMap;
+ }
+
+ public Map<short[], byte[]> shortArrayByteArrayMap() {
+ return shortArrayByteArrayMap;
+ }
+
+ public void shortArrayByteArrayMap(Map<short[], byte[]>
shortArrayByteArrayMap) {
+ this.shortArrayByteArrayMap = shortArrayByteArrayMap;
+ }
+
+ public Map<int[], short[]> intArrayShortArrayMap() {
+ return intArrayShortArrayMap;
+ }
+
+ public void intArrayShortArrayMap(Map<int[], short[]>
intArrayShortArrayMap) {
+ this.intArrayShortArrayMap = intArrayShortArrayMap;
+ }
+
+ public Map<long[], int[]> longArrayIntArrayMap() {
+ return longArrayIntArrayMap;
+ }
+
+ public void longArrayIntArrayMap(Map<long[], int[]> longArrayIntArrayMap) {
+ this.longArrayIntArrayMap = longArrayIntArrayMap;
+ }
+
+ public Map<char[], long[]> charArrayLongArrayMap() {
+ return charArrayLongArrayMap;
+ }
+
+ public void charArrayLongArrayMap(Map<char[], long[]>
charArrayLongArrayMap) {
+ this.charArrayLongArrayMap = charArrayLongArrayMap;
+ }
+
+ public Map<float[], char[]> floatArrayCharArrayMap() {
+ return floatArrayCharArrayMap;
+ }
+
+ public void floatArrayCharArrayMap(Map<float[], char[]>
floatArrayCharArrayMap) {
+ this.floatArrayCharArrayMap = floatArrayCharArrayMap;
+ }
+
+ public Map<double[], float[]> doubleArrayFloatArrayMap() {
+ return doubleArrayFloatArrayMap;
+ }
+
+ public void doubleArrayFloatArrayMap(Map<double[], float[]>
doubleArrayFloatArrayMap) {
+ this.doubleArrayFloatArrayMap = doubleArrayFloatArrayMap;
+ }
+
+ public Map<String, double[]> stringDoubleArrayMap() {
+ return stringDoubleArrayMap;
+ }
+
+ public void stringDoubleArrayMap(Map<String, double[]>
stringDoubleArrayMap) {
+ this.stringDoubleArrayMap = stringDoubleArrayMap;
+ }
+
+ public Map<UUID, String> uuidStringMap() {
+ return uuidStringMap;
+ }
+
+ public void uuidStringMap(Map<UUID, String> uuidStringMap) {
+ this.uuidStringMap = uuidStringMap;
+ }
+
+ public Map<BitSet, UUID> bitSetUuidMap() {
+ return bitSetUuidMap;
+ }
+
+ public void bitSetUuidMap(Map<BitSet, UUID> bitSetUuidMap) {
+ this.bitSetUuidMap = bitSetUuidMap;
+ }
+
+ public Map<IgniteUuid, BitSet> igniteUuidBitSetMap() {
+ return igniteUuidBitSetMap;
+ }
+
+ public void igniteUuidBitSetMap(Map<IgniteUuid, BitSet>
igniteUuidBitSetMap) {
+ this.igniteUuidBitSetMap = igniteUuidBitSetMap;
+ }
+
+ public Map<AffinityTopologyVersion, IgniteUuid>
affTopVersionIgniteUuidMap() {
+ return affTopVersionIgniteUuidMap;
+ }
+
+ public void affTopVersionIgniteUuidMap(Map<AffinityTopologyVersion,
IgniteUuid> affTopVersionIgniteUuidMap) {
+ affTopVersionIgniteUuidMap = affTopVersionIgniteUuidMap;
+ }
+
+ public Map<Boolean, AffinityTopologyVersion>
boxedBooleanAffTopVersionMap() {
+ return boxedBooleanAffTopVersionMap;
+ }
+
+ public void boxedBooleanAffTopVersionMap(Map<Boolean,
AffinityTopologyVersion> boxedBooleanAffTopVersionMap) {
+ this.boxedBooleanAffTopVersionMap = boxedBooleanAffTopVersionMap;
+ }
+
+ public Map<Byte, Boolean> boxedByteBoxedBooleanMap() {
+ return boxedByteBoxedBooleanMap;
+ }
+
+ public void boxedByteBoxedBooleanMap(Map<Byte, Boolean>
boxedByteBoxedBooleanMap) {
+ this.boxedByteBoxedBooleanMap = boxedByteBoxedBooleanMap;
+ }
+
+ public Map<Short, Byte> boxedShortBoxedByteMap() {
+ return boxedShortBoxedByteMap;
+ }
+
+ public void boxedShortBoxedByteMap(Map<Short, Byte>
boxedShortBoxedByteMap) {
+ this.boxedShortBoxedByteMap = boxedShortBoxedByteMap;
+ }
+
+ public Map<Integer, Short> boxedIntBoxedShortMap() {
+ return boxedIntBoxedShortMap;
+ }
+
+ public void boxedIntBoxedShortMap(Map<Integer, Short>
boxedIntBoxedShortMap) {
+ this.boxedIntBoxedShortMap = boxedIntBoxedShortMap;
+ }
+
+ public Map<Long, Integer> boxedLongBoxedIntMap() {
+ return boxedLongBoxedIntMap;
+ }
+
+ public void boxedLongBoxedIntMap(Map<Long, Integer> boxedLongBoxedIntMap) {
+ this.boxedLongBoxedIntMap = boxedLongBoxedIntMap;
+ }
+
+ public Map<Character, Long> boxedCharBoxedLongMap() {
+ return boxedCharBoxedLongMap;
+ }
+
+ public void boxedCharBoxedLongMap(Map<Character, Long>
boxedCharBoxedLongMap) {
+ this.boxedCharBoxedLongMap = boxedCharBoxedLongMap;
+ }
+
+ public Map<Float, Character> boxedFloatBoxedCharMap() {
+ return boxedFloatBoxedCharMap;
+ }
+
+ public void boxedFloatBoxedCharMap(Map<Float, Character>
boxedFloatBoxedCharMap) {
+ this.boxedFloatBoxedCharMap = boxedFloatBoxedCharMap;
+ }
+
+ public Map<Double, Float> boxedDoubleBoxedFloatMap() {
+ return boxedDoubleBoxedFloatMap;
+ }
+
+ public void boxedDoubleBoxedFloatMap(Map<Double, Float>
boxedDoubleBoxedFloatMap) {
+ this.boxedDoubleBoxedFloatMap = boxedDoubleBoxedFloatMap;
+ }
+
+ public Map<GridCacheVersion, Double> messageBoxedDoubleMap() {
+ return messageBoxedDoubleMap;
+ }
+
+ public void messageBoxedDoubleMap(Map<GridCacheVersion, Double>
messageBoxedDoubleMap) {
+ messageBoxedDoubleMap = messageBoxedDoubleMap;
+ }
+
+ public short directType() {
+ return 0;
+ }
+
+ public void onAckReceived() {
+ // No-op.
+ }
+}
diff --git
a/modules/core/src/test/resources/codegen/TestMapMessageSerializer.java
b/modules/core/src/test/resources/codegen/TestMapMessageSerializer.java
new file mode 100644
index 00000000000..d782b5088f1
--- /dev/null
+++ b/modules/core/src/test/resources/codegen/TestMapMessageSerializer.java
@@ -0,0 +1,373 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.ignite.internal.codegen;
+
+import java.nio.ByteBuffer;
+import org.apache.ignite.plugin.extensions.communication.Message;
+import org.apache.ignite.plugin.extensions.communication.MessageSerializer;
+import org.apache.ignite.plugin.extensions.communication.MessageWriter;
+import org.apache.ignite.plugin.extensions.communication.MessageReader;
+import
org.apache.ignite.plugin.extensions.communication.MessageCollectionItemType;
+import org.apache.ignite.internal.TestMapMessage;
+import org.apache.ignite.internal.processors.cache.version.GridCacheVersion;
+
+/**
+ * This class is generated automatically.
+ *
+ * @see org.apache.ignite.internal.MessageProcessor
+ */
+public class TestMapMessageSerializer implements MessageSerializer {
+ /** */
+ @Override public boolean writeTo(Message m, ByteBuffer buf, MessageWriter
writer) {
+ TestMapMessage msg = (TestMapMessage)m;
+
+ writer.setBuffer(buf);
+
+ if (!writer.isHeaderWritten()) {
+ if (!writer.writeHeader(msg.directType()))
+ return false;
+
+ writer.onHeaderWritten();
+ }
+
+ switch (writer.state()) {
+ case 0:
+ if (!writer.writeMap(msg.booleanArrayBoxedLongMap(),
MessageCollectionItemType.BOOLEAN_ARR, MessageCollectionItemType.LONG))
+ return false;
+
+ writer.incrementState();
+
+ case 1:
+ if (!writer.writeMap(msg.byteArrayBooleanArrayMap(),
MessageCollectionItemType.BYTE_ARR, MessageCollectionItemType.BOOLEAN_ARR))
+ return false;
+
+ writer.incrementState();
+
+ case 2:
+ if (!writer.writeMap(msg.shortArrayByteArrayMap(),
MessageCollectionItemType.SHORT_ARR, MessageCollectionItemType.BYTE_ARR))
+ return false;
+
+ writer.incrementState();
+
+ case 3:
+ if (!writer.writeMap(msg.intArrayShortArrayMap(),
MessageCollectionItemType.INT_ARR, MessageCollectionItemType.SHORT_ARR))
+ return false;
+
+ writer.incrementState();
+
+ case 4:
+ if (!writer.writeMap(msg.longArrayIntArrayMap(),
MessageCollectionItemType.LONG_ARR, MessageCollectionItemType.INT_ARR))
+ return false;
+
+ writer.incrementState();
+
+ case 5:
+ if (!writer.writeMap(msg.charArrayLongArrayMap(),
MessageCollectionItemType.CHAR_ARR, MessageCollectionItemType.LONG_ARR))
+ return false;
+
+ writer.incrementState();
+
+ case 6:
+ if (!writer.writeMap(msg.floatArrayCharArrayMap(),
MessageCollectionItemType.FLOAT_ARR, MessageCollectionItemType.CHAR_ARR))
+ return false;
+
+ writer.incrementState();
+
+ case 7:
+ if (!writer.writeMap(msg.doubleArrayFloatArrayMap(),
MessageCollectionItemType.DOUBLE_ARR, MessageCollectionItemType.FLOAT_ARR))
+ return false;
+
+ writer.incrementState();
+
+ case 8:
+ if (!writer.writeMap(msg.stringDoubleArrayMap(),
MessageCollectionItemType.STRING, MessageCollectionItemType.DOUBLE_ARR))
+ return false;
+
+ writer.incrementState();
+
+ case 9:
+ if (!writer.writeMap(msg.uuidStringMap(),
MessageCollectionItemType.UUID, MessageCollectionItemType.STRING))
+ return false;
+
+ writer.incrementState();
+
+ case 10:
+ if (!writer.writeMap(msg.bitSetUuidMap(),
MessageCollectionItemType.BIT_SET, MessageCollectionItemType.UUID))
+ return false;
+
+ writer.incrementState();
+
+ case 11:
+ if (!writer.writeMap(msg.igniteUuidBitSetMap(),
MessageCollectionItemType.IGNITE_UUID, MessageCollectionItemType.BIT_SET))
+ return false;
+
+ writer.incrementState();
+
+ case 12:
+ if (!writer.writeMap(msg.affTopVersionIgniteUuidMap(),
MessageCollectionItemType.AFFINITY_TOPOLOGY_VERSION,
MessageCollectionItemType.IGNITE_UUID))
+ return false;
+
+ writer.incrementState();
+
+ case 13:
+ if (!writer.writeMap(msg.boxedBooleanAffTopVersionMap(),
MessageCollectionItemType.BOOLEAN,
MessageCollectionItemType.AFFINITY_TOPOLOGY_VERSION))
+ return false;
+
+ writer.incrementState();
+
+ case 14:
+ if (!writer.writeMap(msg.boxedByteBoxedBooleanMap(),
MessageCollectionItemType.BYTE, MessageCollectionItemType.BOOLEAN))
+ return false;
+
+ writer.incrementState();
+
+ case 15:
+ if (!writer.writeMap(msg.boxedShortBoxedByteMap(),
MessageCollectionItemType.SHORT, MessageCollectionItemType.BYTE))
+ return false;
+
+ writer.incrementState();
+
+ case 16:
+ if (!writer.writeMap(msg.boxedIntBoxedShortMap(),
MessageCollectionItemType.INT, MessageCollectionItemType.SHORT))
+ return false;
+
+ writer.incrementState();
+
+ case 17:
+ if (!writer.writeMap(msg.boxedLongBoxedIntMap(),
MessageCollectionItemType.LONG, MessageCollectionItemType.INT))
+ return false;
+
+ writer.incrementState();
+
+ case 18:
+ if (!writer.writeMap(msg.boxedCharBoxedLongMap(),
MessageCollectionItemType.CHAR, MessageCollectionItemType.LONG))
+ return false;
+
+ writer.incrementState();
+
+ case 19:
+ if (!writer.writeMap(msg.boxedFloatBoxedCharMap(),
MessageCollectionItemType.FLOAT, MessageCollectionItemType.CHAR))
+ return false;
+
+ writer.incrementState();
+
+ case 20:
+ if (!writer.writeMap(msg.boxedDoubleBoxedFloatMap(),
MessageCollectionItemType.DOUBLE, MessageCollectionItemType.FLOAT))
+ return false;
+
+ writer.incrementState();
+
+ case 21:
+ if (!writer.writeMap(msg.messageBoxedDoubleMap(),
MessageCollectionItemType.MSG, MessageCollectionItemType.DOUBLE))
+ return false;
+
+ writer.incrementState();
+
+ }
+
+ return true;
+ }
+
+ /** */
+ @Override public boolean readFrom(Message m, ByteBuffer buf, MessageReader
reader) {
+ TestMapMessage msg = (TestMapMessage)m;
+
+ reader.setBuffer(buf);
+
+ switch (reader.state()) {
+ case 0:
+
msg.booleanArrayBoxedLongMap(reader.readMap(MessageCollectionItemType.BOOLEAN_ARR,
MessageCollectionItemType.LONG, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 1:
+
msg.byteArrayBooleanArrayMap(reader.readMap(MessageCollectionItemType.BYTE_ARR,
MessageCollectionItemType.BOOLEAN_ARR, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 2:
+
msg.shortArrayByteArrayMap(reader.readMap(MessageCollectionItemType.SHORT_ARR,
MessageCollectionItemType.BYTE_ARR, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 3:
+
msg.intArrayShortArrayMap(reader.readMap(MessageCollectionItemType.INT_ARR,
MessageCollectionItemType.SHORT_ARR, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 4:
+
msg.longArrayIntArrayMap(reader.readMap(MessageCollectionItemType.LONG_ARR,
MessageCollectionItemType.INT_ARR, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 5:
+
msg.charArrayLongArrayMap(reader.readMap(MessageCollectionItemType.CHAR_ARR,
MessageCollectionItemType.LONG_ARR, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 6:
+
msg.floatArrayCharArrayMap(reader.readMap(MessageCollectionItemType.FLOAT_ARR,
MessageCollectionItemType.CHAR_ARR, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 7:
+
msg.doubleArrayFloatArrayMap(reader.readMap(MessageCollectionItemType.DOUBLE_ARR,
MessageCollectionItemType.FLOAT_ARR, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 8:
+
msg.stringDoubleArrayMap(reader.readMap(MessageCollectionItemType.STRING,
MessageCollectionItemType.DOUBLE_ARR, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 9:
+
msg.uuidStringMap(reader.readMap(MessageCollectionItemType.UUID,
MessageCollectionItemType.STRING, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 10:
+
msg.bitSetUuidMap(reader.readMap(MessageCollectionItemType.BIT_SET,
MessageCollectionItemType.UUID, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 11:
+
msg.igniteUuidBitSetMap(reader.readMap(MessageCollectionItemType.IGNITE_UUID,
MessageCollectionItemType.BIT_SET, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 12:
+
msg.affTopVersionIgniteUuidMap(reader.readMap(MessageCollectionItemType.AFFINITY_TOPOLOGY_VERSION,
MessageCollectionItemType.IGNITE_UUID, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 13:
+
msg.boxedBooleanAffTopVersionMap(reader.readMap(MessageCollectionItemType.BOOLEAN,
MessageCollectionItemType.AFFINITY_TOPOLOGY_VERSION, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 14:
+
msg.boxedByteBoxedBooleanMap(reader.readMap(MessageCollectionItemType.BYTE,
MessageCollectionItemType.BOOLEAN, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 15:
+
msg.boxedShortBoxedByteMap(reader.readMap(MessageCollectionItemType.SHORT,
MessageCollectionItemType.BYTE, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 16:
+
msg.boxedIntBoxedShortMap(reader.readMap(MessageCollectionItemType.INT,
MessageCollectionItemType.SHORT, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 17:
+
msg.boxedLongBoxedIntMap(reader.readMap(MessageCollectionItemType.LONG,
MessageCollectionItemType.INT, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 18:
+
msg.boxedCharBoxedLongMap(reader.readMap(MessageCollectionItemType.CHAR,
MessageCollectionItemType.LONG, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 19:
+
msg.boxedFloatBoxedCharMap(reader.readMap(MessageCollectionItemType.FLOAT,
MessageCollectionItemType.CHAR, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 20:
+
msg.boxedDoubleBoxedFloatMap(reader.readMap(MessageCollectionItemType.DOUBLE,
MessageCollectionItemType.FLOAT, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ case 21:
+
msg.messageBoxedDoubleMap(reader.readMap(MessageCollectionItemType.MSG,
MessageCollectionItemType.DOUBLE, false));
+
+ if (!reader.isLastRead())
+ return false;
+
+ reader.incrementState();
+
+ }
+
+ return true;
+ }
+}
