Vladsz83 commented on code in PR #13095: URL: https://github.com/apache/ignite/pull/13095#discussion_r3660084124
########## modules/codegen/src/main/java/org/apache/ignite/internal/MessageDeploymentGenerator.java: ########## @@ -0,0 +1,247 @@ +/* + * 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.io.IOException; +import java.io.StringWriter; +import java.io.Writer; +import java.util.ArrayList; +import java.util.List; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeKind; +import javax.lang.model.type.TypeMirror; +import javax.lang.model.type.WildcardType; +import org.jetbrains.annotations.Nullable; + +import static org.apache.ignite.internal.MessageProcessor.CACHE_OBJECT_CLS; + +/** + * Generates a {@code *Deployer} class for messages whose {@code @Order} fields have a type that indicates deployment + * need: {@code CacheObject} subtypes, {@code Collection<? extends CacheObject>}, {@code Iterable<IgniteTxEntry>}, or a + * nested {@code GridCacheMessage} (whose deployment is delegated). The strategy is inferred entirely from the field type. + * + * <p>A message with deployment logic that cannot be inferred from field types implements {@code DeployableMessage}; + * the generated deployer then also delegates to its {@code deploy}, mirroring {@code marshal}. + */ +public class MessageDeploymentGenerator extends MessageGenerator { + /** */ + private final TypeMirror gridCacheMsgType; + + /** */ + private final TypeMirror deployableMsgType; + + /** */ + private final TypeMirror cacheObjType; + + /** */ + private final TypeMirror txEntryType; + + /** */ + private final TypeMirror colType; + + /** */ + private final TypeMirror iterableType; + + /** Accumulated source lines for the generated {@code GridCacheMessageDeployer#deploy} implementation. */ + private final List<String> deploy = new ArrayList<>(); + + /** */ + private boolean needsCctx; + + /** */ + MessageDeploymentGenerator(ProcessingEnvironment env) { + super(env); + + gridCacheMsgType = type("org.apache.ignite.internal.processors.cache.GridCacheMessage"); Review Comment: In `MessageProcessor` we use constants. ########## modules/codegen/src/main/java/org/apache/ignite/internal/MessageSerializerGenerator.java: ########## @@ -93,159 +60,69 @@ public class MessageSerializerGenerator { private static final String COMPRESSED_MSG_ERROR = "CompressedMessage should not be used explicitly. " + "To compress the required field use the @Compress annotation."; - /** Collection of lines for {@code writeTo} method. */ + /** */ private final List<String> write = new ArrayList<>(); - /** Collection of lines for {@code readFrom} method. */ - private final List<String> read = new ArrayList<>(); - - /** Collection of message-specific imports. */ - private final Set<String> imports = new TreeSet<>(); - - /** Collection of Serializer class fields containing mappers for message enum fields. */ - private final Set<String> fields = new TreeSet<>(); - /** */ - private final ProcessingEnvironment env; - - /** Stored type of the message being processed. */ - private TypeElement type; - - /** The marshallable message type. */ - private final TypeMirror marshallableMsgType; + private final List<String> read = new ArrayList<>(); - /** */ - private int indent; + /** Class-field declarations (enum mappers/values, collection descriptors) emitted at the top of the generated class. */ + private final Set<String> clsFields = new TreeSet<>(); /** */ MessageSerializerGenerator(ProcessingEnvironment env) { - this.env = env; - - marshallableMsgType = env.getElementUtils().getTypeElement(MARSHALLABLE_MESSAGE_INTERFACE).asType(); + super(env); } - /** */ - void generate(TypeElement type, List<VariableElement> fields) throws Exception { - assert this.type == null : "Message serializer generator isn't stateless and is supposed to be single-use."; - - this.type = type; + /** {@inheritDoc} */ + @Override String typeSuffix() { + return "Serializer"; + } + /** {@inheritDoc} */ + @Override void generateBody(List<VariableElement> fields) throws Exception { generateMethods(fields); + // Include superclass types in imports so generated code can cast to them for inherited fields. SystemViewRowAttributeWalkerProcessor.superclasses(env, type).forEach(el -> imports.add(el.toString())); - - String serClsName = type.getSimpleName() + (marshallableMessage() ? "Marshallable" : "") + "Serializer"; - String serFqnClsName = env.getElementUtils().getPackageOf(type) + "." + serClsName; - String serCode = generateSerializerCode(serClsName); - - try { - JavaFileObject file = env.getFiler().createSourceFile(serFqnClsName); - - try (Writer writer = file.openWriter()) { - writer.append(serCode); - writer.flush(); - } - } - catch (FilerException e) { - // IntelliJ IDEA parses Ignite's pom.xml and configures itself to use this annotation processor on each Run. - // During a Run, it invokes the processor and may fail when attempting to generate sources that already exist. - // There is no a setting to disable this invocation. The IntelliJ community suggests a workaround — delegating - // all Run commands to Maven. However, this significantly slows down test startup time. - // This hack checks whether the content of a generating file is identical to already existed file, and skips - // handling this class if it is. - if (!identicalFileIsAlreadyGenerated(env, serCode, serFqnClsName)) { - env.getMessager().printMessage( - Diagnostic.Kind.ERROR, - "MessageSerializer " + serClsName + " is already generated. Try 'mvn clean install' to fix the issue."); - - throw e; - } - } } - /** Generates full code for a serializer class. */ - private String generateSerializerCode(String serClsName) throws IOException { - if (marshallableMessage()) { - fields.add("private final Marshaller marshaller;"); - fields.add("private final ClassLoader clsLdr;"); - } - + /** {@inheritDoc} */ + @Override String buildClassCode(String serClsName) throws IOException { try (Writer writer = new StringWriter()) { - writeClassHeader(writer, env.getElementUtils().getPackageOf(type).toString(), serClsName); + imports.add(type.toString()); + imports.add("org.apache.ignite.plugin.extensions.communication.MessageSerializer"); Review Comment: constants maybe? ########## modules/codegen/src/main/java/org/apache/ignite/internal/MessageMarshallerGenerator.java: ########## @@ -0,0 +1,1180 @@ +/* + * 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.io.IOException; +import java.io.StringWriter; +import java.io.Writer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.function.BiFunction; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.QualifiedNameable; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.ArrayType; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeKind; +import javax.lang.model.type.TypeMirror; +import javax.lang.model.type.TypeVariable; +import javax.lang.model.util.ElementFilter; +import javax.tools.Diagnostic; +import org.apache.ignite.internal.systemview.SystemViewRowAttributeWalkerProcessor; +import org.jetbrains.annotations.Nullable; + +import static org.apache.ignite.internal.MessageProcessor.CACHE_OBJECT_CLS; +import static org.apache.ignite.internal.MessageProcessor.KEY_CACHE_OBJECT_CLS; +import static org.apache.ignite.internal.MessageProcessor.MARSHALLABLE_MESSAGE_INTERFACE; +import static org.apache.ignite.internal.MessageProcessor.MESSAGE_INTERFACE; +import static org.apache.ignite.internal.MessageProcessor.NON_MARSHALLABLE_MESSAGE_INTERFACE; + +/** + * Generates {@code *Marshaller} classes for {@code Message} types that are not {@code NonMarshallableMessage}. + */ +public class MessageMarshallerGenerator extends MessageGenerator { + /** Accumulated source lines for all generated marshal/unmarshal methods. */ + private final List<String> marshall = new ArrayList<>(); + + /** */ + private final TypeMirror marshallableMsgType; + + /** */ + private final TypeMirror msgType; + + /** */ + private final TypeMirror cacheObjType; + + /** */ + private final TypeMirror nonMarshallableType; + + /** */ + private final TypeMirror cacheGrpIdMsgType; + + /** */ + private final TypeMirror mapType; + + /** */ + private final TypeMirror colType; + + /** */ + private boolean marshallable; + + /** */ + private boolean hasMarshalled; + + /** Whether any generated method got a non-empty body; a marshaller without one is skipped entirely. */ + private boolean hasStatements; + + /** Enclosed fields of the currently processed type. Computed once per {@link #generateBody} call. */ + private Map<String, VariableElement> enclosed; + + /** {@link MarshalledKind} of each {@code @Marshalled} enclosed field. Computed once per {@link #generateBody} call. */ + private final Map<VariableElement, MarshalledKind> kinds = new HashMap<>(); + + /** Nesting depth of the current marshal for-loop; names loop variables {@code e}, {@code e1}, {@code e2}… */ + private int loopDepth; + + /** Whether the currently generated method emitted a loop-nested facade call and so needs the {@code msgFactory} local. */ + private boolean usesMsgFactory; + + /** */ + MessageMarshallerGenerator(ProcessingEnvironment env) { + super(env); + + marshallableMsgType = type(MARSHALLABLE_MESSAGE_INTERFACE); + msgType = type(MESSAGE_INTERFACE); + cacheObjType = type(CACHE_OBJECT_CLS); + nonMarshallableType = type(NON_MARSHALLABLE_MESSAGE_INTERFACE); + cacheGrpIdMsgType = type("org.apache.ignite.internal.processors.cache.GridCacheGroupIdMessage"); + mapType = type("java.util.Map"); + colType = type("java.util.Collection"); + } + + /** {@inheritDoc} */ + @Override String typeSuffix() { + return "Marshaller"; + } + + /** {@inheritDoc} */ + @Override boolean shouldSkip(TypeElement type, List<VariableElement> fields) { + return isNonMarshallableMessage(type); + } + + /** {@inheritDoc} */ + @Override void generateBody(List<VariableElement> fields) throws Exception { + enclosed = enclosedFields(); + + for (VariableElement f : enclosed.values()) { + MarshalledKind kind = marshalledKind(f); + + if (kind != null) + kinds.put(f, kind); + } + + marshallable = marshallableMsgType != null && assignableFrom(type.asType(), marshallableMsgType); + hasMarshalled = kinds.values().stream().anyMatch(k -> k == MarshalledKind.BLOB || k == MarshalledKind.ELEMENT_BLOBS); + + generateMarshalMethod(fields); + generateUnmarshalMethods(fields); + } + + /** {@inheritDoc} */ + @Override String buildClassCode(String marshallerClsName) throws IOException { + if (!hasStatements) + return null; + + try (Writer writer = new StringWriter()) { + imports.add(type.toString()); + imports.add("org.apache.ignite.plugin.extensions.communication.MessageMarshaller"); Review Comment: A shared constant maybe? ########## modules/codegen/src/main/java/org/apache/ignite/internal/MessageMarshallerGenerator.java: ########## @@ -0,0 +1,1180 @@ +/* + * 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.io.IOException; +import java.io.StringWriter; +import java.io.Writer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.function.BiFunction; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.QualifiedNameable; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.ArrayType; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeKind; +import javax.lang.model.type.TypeMirror; +import javax.lang.model.type.TypeVariable; +import javax.lang.model.util.ElementFilter; +import javax.tools.Diagnostic; +import org.apache.ignite.internal.systemview.SystemViewRowAttributeWalkerProcessor; +import org.jetbrains.annotations.Nullable; + +import static org.apache.ignite.internal.MessageProcessor.CACHE_OBJECT_CLS; +import static org.apache.ignite.internal.MessageProcessor.KEY_CACHE_OBJECT_CLS; +import static org.apache.ignite.internal.MessageProcessor.MARSHALLABLE_MESSAGE_INTERFACE; +import static org.apache.ignite.internal.MessageProcessor.MESSAGE_INTERFACE; +import static org.apache.ignite.internal.MessageProcessor.NON_MARSHALLABLE_MESSAGE_INTERFACE; + +/** + * Generates {@code *Marshaller} classes for {@code Message} types that are not {@code NonMarshallableMessage}. + */ +public class MessageMarshallerGenerator extends MessageGenerator { + /** Accumulated source lines for all generated marshal/unmarshal methods. */ + private final List<String> marshall = new ArrayList<>(); + + /** */ + private final TypeMirror marshallableMsgType; + + /** */ + private final TypeMirror msgType; + + /** */ + private final TypeMirror cacheObjType; + + /** */ + private final TypeMirror nonMarshallableType; + + /** */ + private final TypeMirror cacheGrpIdMsgType; + + /** */ + private final TypeMirror mapType; + + /** */ + private final TypeMirror colType; + + /** */ + private boolean marshallable; + + /** */ + private boolean hasMarshalled; + + /** Whether any generated method got a non-empty body; a marshaller without one is skipped entirely. */ + private boolean hasStatements; + + /** Enclosed fields of the currently processed type. Computed once per {@link #generateBody} call. */ + private Map<String, VariableElement> enclosed; + + /** {@link MarshalledKind} of each {@code @Marshalled} enclosed field. Computed once per {@link #generateBody} call. */ + private final Map<VariableElement, MarshalledKind> kinds = new HashMap<>(); + + /** Nesting depth of the current marshal for-loop; names loop variables {@code e}, {@code e1}, {@code e2}… */ + private int loopDepth; + + /** Whether the currently generated method emitted a loop-nested facade call and so needs the {@code msgFactory} local. */ + private boolean usesMsgFactory; + + /** */ + MessageMarshallerGenerator(ProcessingEnvironment env) { + super(env); + + marshallableMsgType = type(MARSHALLABLE_MESSAGE_INTERFACE); + msgType = type(MESSAGE_INTERFACE); + cacheObjType = type(CACHE_OBJECT_CLS); + nonMarshallableType = type(NON_MARSHALLABLE_MESSAGE_INTERFACE); + cacheGrpIdMsgType = type("org.apache.ignite.internal.processors.cache.GridCacheGroupIdMessage"); + mapType = type("java.util.Map"); + colType = type("java.util.Collection"); + } + + /** {@inheritDoc} */ + @Override String typeSuffix() { + return "Marshaller"; + } + + /** {@inheritDoc} */ + @Override boolean shouldSkip(TypeElement type, List<VariableElement> fields) { + return isNonMarshallableMessage(type); + } + + /** {@inheritDoc} */ + @Override void generateBody(List<VariableElement> fields) throws Exception { Review Comment: Doesn't need `throws Exception` ########## modules/codegen/src/main/java/org/apache/ignite/internal/MessageMarshallerGenerator.java: ########## @@ -0,0 +1,1180 @@ +/* + * 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.io.IOException; +import java.io.StringWriter; +import java.io.Writer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.function.BiFunction; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.QualifiedNameable; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.ArrayType; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeKind; +import javax.lang.model.type.TypeMirror; +import javax.lang.model.type.TypeVariable; +import javax.lang.model.util.ElementFilter; +import javax.tools.Diagnostic; +import org.apache.ignite.internal.systemview.SystemViewRowAttributeWalkerProcessor; +import org.jetbrains.annotations.Nullable; + +import static org.apache.ignite.internal.MessageProcessor.CACHE_OBJECT_CLS; +import static org.apache.ignite.internal.MessageProcessor.KEY_CACHE_OBJECT_CLS; +import static org.apache.ignite.internal.MessageProcessor.MARSHALLABLE_MESSAGE_INTERFACE; +import static org.apache.ignite.internal.MessageProcessor.MESSAGE_INTERFACE; +import static org.apache.ignite.internal.MessageProcessor.NON_MARSHALLABLE_MESSAGE_INTERFACE; + +/** + * Generates {@code *Marshaller} classes for {@code Message} types that are not {@code NonMarshallableMessage}. + */ +public class MessageMarshallerGenerator extends MessageGenerator { + /** Accumulated source lines for all generated marshal/unmarshal methods. */ + private final List<String> marshall = new ArrayList<>(); + + /** */ + private final TypeMirror marshallableMsgType; + + /** */ + private final TypeMirror msgType; + + /** */ + private final TypeMirror cacheObjType; + + /** */ + private final TypeMirror nonMarshallableType; + + /** */ + private final TypeMirror cacheGrpIdMsgType; + + /** */ + private final TypeMirror mapType; + + /** */ + private final TypeMirror colType; + + /** */ + private boolean marshallable; + + /** */ + private boolean hasMarshalled; + + /** Whether any generated method got a non-empty body; a marshaller without one is skipped entirely. */ + private boolean hasStatements; + + /** Enclosed fields of the currently processed type. Computed once per {@link #generateBody} call. */ + private Map<String, VariableElement> enclosed; + + /** {@link MarshalledKind} of each {@code @Marshalled} enclosed field. Computed once per {@link #generateBody} call. */ + private final Map<VariableElement, MarshalledKind> kinds = new HashMap<>(); + + /** Nesting depth of the current marshal for-loop; names loop variables {@code e}, {@code e1}, {@code e2}… */ + private int loopDepth; + + /** Whether the currently generated method emitted a loop-nested facade call and so needs the {@code msgFactory} local. */ + private boolean usesMsgFactory; + + /** */ + MessageMarshallerGenerator(ProcessingEnvironment env) { + super(env); + + marshallableMsgType = type(MARSHALLABLE_MESSAGE_INTERFACE); + msgType = type(MESSAGE_INTERFACE); + cacheObjType = type(CACHE_OBJECT_CLS); + nonMarshallableType = type(NON_MARSHALLABLE_MESSAGE_INTERFACE); + cacheGrpIdMsgType = type("org.apache.ignite.internal.processors.cache.GridCacheGroupIdMessage"); + mapType = type("java.util.Map"); + colType = type("java.util.Collection"); + } + + /** {@inheritDoc} */ + @Override String typeSuffix() { + return "Marshaller"; + } + + /** {@inheritDoc} */ + @Override boolean shouldSkip(TypeElement type, List<VariableElement> fields) { + return isNonMarshallableMessage(type); + } + + /** {@inheritDoc} */ + @Override void generateBody(List<VariableElement> fields) throws Exception { + enclosed = enclosedFields(); + + for (VariableElement f : enclosed.values()) { + MarshalledKind kind = marshalledKind(f); + + if (kind != null) + kinds.put(f, kind); + } + + marshallable = marshallableMsgType != null && assignableFrom(type.asType(), marshallableMsgType); + hasMarshalled = kinds.values().stream().anyMatch(k -> k == MarshalledKind.BLOB || k == MarshalledKind.ELEMENT_BLOBS); + + generateMarshalMethod(fields); + generateUnmarshalMethods(fields); + } + + /** {@inheritDoc} */ + @Override String buildClassCode(String marshallerClsName) throws IOException { + if (!hasStatements) + return null; + + try (Writer writer = new StringWriter()) { + imports.add(type.toString()); + imports.add("org.apache.ignite.plugin.extensions.communication.MessageMarshaller"); + + if (marshallable || hasMarshalled) + imports.add("org.apache.ignite.marshaller.Marshaller"); + + writeClassHeader(writer, "MessageMarshaller", marshallerClsName); + + writer.write(" {" + NL); + + writeConstructor(writer, marshallerClsName); + + for (String line : marshall) + writer.write(line + NL); + + writer.write("}"); + + return writer.toString(); + } + } + + /** Writes the {@code marshaller} field and the constructor initializing it, when the marshaller is needed. */ + private void writeConstructor(Writer writer, String marshallerClsName) throws IOException { + if (!marshallable && !hasMarshalled) + return; + + writer.write(indentedLine(METHOD_JAVADOC)); + writer.write(NL); + writer.write(indentedLine("private final Marshaller marshaller;")); + writer.write(NL + NL); + + writer.write(indentedLine(METHOD_JAVADOC)); + writer.write(NL); + writer.write(indentedLine("public " + marshallerClsName + "(Marshaller marshaller) {")); + writer.write(NL); + + indent++; + + writer.write(indentedLine("this.marshaller = marshaller;")); + writer.write(NL); + + indent--; + + writer.write(indentedLine("}")); + writer.write(NL + NL); + } + + /** Generates the {@code marshal} method body and appends it to {@link #marshall}. */ + private void generateMarshalMethod(List<VariableElement> orderedFields) { + imports.add("org.apache.ignite.IgniteCheckedException"); + imports.add("org.apache.ignite.internal.GridKernalContext"); + imports.add("org.apache.ignite.internal.processors.cache.CacheObjectContext"); + + String signature = "marshal(" + simpleNameWithGeneric(type) + " msg, GridKernalContext kctx, CacheObjectContext cacheObjCtx)"; + + hasStatements |= emitMethod(marshall, signature, body -> { + usesMsgFactory = false; + + if (needsCtx(orderedFields)) + appendBlock(body, List.of(ctxResolutionLine())); + + appendMarshalledFieldsPrepare(body); + appendMarshalledPrepare(body); + + if (marshallable) + appendBlock(body, List.of(indentedLine("msg.marshal(marshaller);"))); + + appendFields(body, orderedFields, MarshalMode.MARSHAL); + + prependMsgFactoryResolution(body); + }); + } + + /** Generates all {@code unmarshal} overloads and appends them to {@link #marshall}. */ + private void generateUnmarshalMethods(List<VariableElement> orderedFields) { + List<VariableElement> nioFields = new ArrayList<>(); + List<VariableElement> workerFields = new ArrayList<>(); + + for (VariableElement f : orderedFields) { + boolean nioField = isNioField(f); + + if (nioField && isMessage(f.asType()) && !nestedNeedsCtx(f.asType())) + nioFields.add(f); + else { + if (nioField && !isMessage(f.asType())) + env.getMessager().printMessage(Diagnostic.Kind.ERROR, + "@NioField has no effect on non-Message field '" + f.getSimpleName() + "' of type " + f.asType(), f); + else if (nioField) + env.getMessager().printMessage(Diagnostic.Kind.ERROR, + "@NioField field '" + f.getSimpleName() + "' of type " + f.asType() + " needs a cache object " + + "context to unmarshal, but the NIO thread has none; only context-free messages may be @NioField", f); + + workerFields.add(f); + } + } + + // U is referenced only by @Marshalled handling. + boolean usesU = enclosed.values().stream().anyMatch(f -> f.getAnnotation(Marshalled.class) != null); + + if (usesU) + imports.add("org.apache.ignite.internal.util.typedef.internal.U"); + + String msgParam = simpleNameWithGeneric(type) + " msg, GridKernalContext kctx"; + + generateUnmarshalMethod(msgParam + ", CacheObjectContext cacheObjCtx, ClassLoader clsLdr", workerFields); + + if (!nioFields.isEmpty()) + generateUnmarshalNioMethod(msgParam, nioFields); + } + + /** Generates the cache-aware {@code unmarshal} overload: the full field set, with cache context and deployment class loader. */ + private void generateUnmarshalMethod(String params, List<VariableElement> fields) { + hasStatements |= emitMethod(marshall, "unmarshal(" + params + ")", body -> { + usesMsgFactory = false; + + Set<String> wireFieldSkip = marshalledWireFieldsToSkip(); + + if (needsCtx(fields) || !wireFieldSkip.isEmpty()) + appendBlock(body, List.of(ctxResolutionLine())); + + appendFields(body, fields, MarshalMode.UNMARSHAL, wireFieldSkip); + + if (marshallable) + appendBlock(body, List.of(indentedLine("msg.unmarshal(marshaller, clsLdr);"))); + + appendMarshalledFinish(body); + + appendMarshalledElementsFinish(body); + appendMarshalledMapFinish(body); + appendMarshalledElementBlobsFinish(body); + + prependMsgFactoryResolution(body); + }); + } + + /** Generates the {@code unmarshalNio} method for NIO-eligible {@code @Message} fields. */ + private void generateUnmarshalNioMethod(String params, List<VariableElement> nioFields) { + hasStatements |= emitMethod(marshall, "unmarshalNio(" + params + ")", body -> { + for (VariableElement f : nioFields) + appendBlock(body, unmarshalNioField(fieldAccessor(f))); + }); + } + + /** Cache-free unmarshal of a {@code @NioField} message field on the NIO thread (no cache context available). */ + private List<String> unmarshalNioField(String accessor) { + imports.add("org.apache.ignite.internal.managers.communication.MessageMarshalling"); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null)", accessor)); + + indent++; + + code.add(indentedLine("MessageMarshalling.unmarshal(%s, kctx);", accessor)); + + indent--; + + return code; + } + + /** Generates logical→wire conversions for the element-, blob-list- and map-flavoured {@code @Marshalled} fields. */ + private void appendMarshalledFieldsPrepare(List<String> body) { + for (VariableElement field : enclosed.values()) { + appendCollectionPrepare(body, field); + appendMapPrepare(body, field); + appendObjectsPrepare(body, field); + } + } + + /** Generates the {@code Collection<byte[]>} build-up for a per-element-blobs {@code @Marshalled} field in marshal. */ + private void appendObjectsPrepare(List<String> body, VariableElement field) { + if (kinds.get(field) != MarshalledKind.ELEMENT_BLOBS) + return; + + Marshalled ann = field.getAnnotation(Marshalled.class); + + String objField = "msg." + field.getSimpleName(); + String bytesField = "msg." + ann.value(); + + imports.add("java.util.ArrayList"); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null && %s == null) {", objField, bytesField)); + + indent++; + + code.add(indentedLine("%s = new ArrayList<>(%s.size());", bytesField, objField)); + code.add(EMPTY); + code.add(indentedLine("for (Object e : %s)", objField)); + + indent++; + + code.add(indentedLine("%s.add(U.marshal(marshaller, e));", bytesField)); + + indent--; + indent--; + + code.add(indentedLine("}")); + + appendBlock(body, code); + } + + /** Appends a {@code toArray} assignment for a per-element {@code @Marshalled} field, if present. */ + private void appendCollectionPrepare(List<String> body, VariableElement field) { + if (kinds.get(field) != MarshalledKind.ELEMENTS) + return; + + Marshalled ann = field.getAnnotation(Marshalled.class); + + String colField = "msg." + field.getSimpleName(); + String arrField = "msg." + ann.value(); + String compName = arrayComponentName(requireEnclosed(enclosed, ann.value(), "@Marshalled")); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null && %s == null)", colField, arrField)); + + indent++; + + code.add(indentedLine("%s = %s.toArray(new %s[0]);", arrField, colField, compName)); + + indent--; + + appendBlock(body, code); + } + + /** Appends key/value array assignments for a map-flavoured {@code @Marshalled} field, if present. */ + private void appendMapPrepare(List<String> body, VariableElement field) { + if (kinds.get(field) != MarshalledKind.MAP) + return; + + Marshalled ann = field.getAnnotation(Marshalled.class); + + String mapField = "msg." + field.getSimpleName(); + String keysField = "msg." + ann.keys(); + String valuesField = "msg." + ann.values(); + VariableElement keysEl = requireEnclosed(enclosed, ann.keys(), "@Marshalled"); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null && %s == null) {", mapField, keysField)); + + indent++; + + code.addAll(keysEl.asType().getKind() == TypeKind.ARRAY + ? arrayMapBody(ann, mapField, keysField, keysEl, valuesField) + : viewBasedMapBody(keysField, mapField, valuesField)); + + indent--; + + code.add(indentedLine("}")); + + appendBlock(body, code); + } + + /** Generates {@code U.marshal} calls for all {@code @Marshalled} fields in marshal. */ + private void appendMarshalledPrepare(List<String> body) { + forEachMarshalled((bytesAcc, objAcc) -> { + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null && %s == null)", objAcc, bytesAcc)); + + indent++; + + code.add(indentedLine("%s = U.marshal(marshaller, %s);", bytesAcc, objAcc)); + + indent--; + + return code; + }, body); + } + + /** Generates {@code U.unmarshal} calls for all {@code @Marshalled} fields in the cache-aware unmarshal. */ + private void appendMarshalledFinish(List<String> body) { + forEachMarshalled((bytesAcc, objAcc) -> { + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null) {", bytesAcc)); + + indent++; + + code.add(indentedLine("%s = U.unmarshal(marshaller, %s, clsLdr);", objAcc, bytesAcc)); + code.add(EMPTY); + + // Drop the serialized cache once the object is restored: keeping both the deserialized value and its bytes + // on every received message doubles retained memory (e.g. topology history nodes) and can exhaust the heap. + code.add(indentedLine("%s = null;", bytesAcc)); + + indent--; + + code.add(indentedLine("}")); + + return code; + }, body); + } + + /** Generates Set reconstruction for all {@link MarshalledKind#ELEMENTS} {@code @Marshalled} fields. */ + private void appendMarshalledElementsFinish(List<String> body) { + for (VariableElement field : enclosed.values()) { + if (kinds.get(field) != MarshalledKind.ELEMENTS) + continue; + + Marshalled colAnn = field.getAnnotation(Marshalled.class); + + String colField = "msg." + field.getSimpleName(); + String arrField = "msg." + colAnn.value(); + VariableElement wireField = requireEnclosed(enclosed, colAnn.value(), "@Marshalled"); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null) {", arrField)); + + indent++; + + code.add(indentedLine("%s = U.newHashSet(%s.length);", colField, arrField)); + code.add(EMPTY); + code.addAll(collectionFinishForBlock(wireField, colField, arrField, field.getSimpleName().toString())); + code.add(EMPTY); + code.add(indentedLine("%s = null;", arrField)); + + indent--; + + code.add(indentedLine("}")); + + appendBlock(body, code); + } + } + + /** Generates Collection reconstruction for {@link MarshalledKind#ELEMENT_BLOBS} {@code @Marshalled} fields (cache-aware pass only). */ + private void appendMarshalledElementBlobsFinish(List<String> body) { + for (VariableElement field : enclosed.values()) { + if (kinds.get(field) != MarshalledKind.ELEMENT_BLOBS) + continue; + + Marshalled ann = field.getAnnotation(Marshalled.class); + + String objField = "msg." + field.getSimpleName(); + String bytesField = "msg." + ann.value(); + + imports.add("java.util.ArrayList"); + imports.add("java.util.Map"); + imports.add(KEY_CACHE_OBJECT_CLS); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null) {", bytesField)); + + indent++; + + code.add(indentedLine("%s = new ArrayList<>(%s.size());", objField, bytesField)); + code.add(EMPTY); + code.add(indentedLine("for (byte[] e : %s) {", bytesField)); + + indent++; + + code.add(indentedLine("Object o = U.unmarshal(marshaller, e, clsLdr);")); + code.add(EMPTY); + code.add(indentedLine("if (o instanceof Map.Entry) {")); + + indent++; + + code.add(indentedLine("Object key = ((Map.Entry<?, ?>)o).getKey();")); + code.add(EMPTY); + code.add(indentedLine("if (key instanceof KeyCacheObject)")); + + indent++; + + code.add(indentedLine("((KeyCacheObject)key).unmarshal(ctx, clsLdr);")); + + indent--; + indent--; + + code.add(indentedLine("}")); + code.add(EMPTY); + code.add(indentedLine("%s.add(o);", objField)); + + indent--; + + code.add(indentedLine("}")); + code.add(EMPTY); + code.add(indentedLine("%s = null;", bytesField)); + + indent--; + + code.add(indentedLine("}")); + + appendBlock(body, code); + } + } + + /** Generates the {@code for} loop body: per-element unmarshal + try/catch add into the collection. */ + private List<String> collectionFinishForBlock(VariableElement wireField, String colField, String arrField, String fieldName) { + String compName = arrayComponentName(wireField); + TypeMirror compType = ((ArrayType)wireField.asType()).getComponentType(); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("for (%s e : %s) {", compName, arrField)); + + indent++; + + code.addAll(codeFor(compType, "e", MarshalMode.UNMARSHAL)); + code.add(EMPTY); + code.add(indentedLine("%s.add(e);", colField)); + + indent--; + + code.add(indentedLine("}")); + + return code; + } + + /** Returns names of wire fields skipped by {@link #appendFields} in UNMARSHAL mode. */ + private Set<String> marshalledWireFieldsToSkip() { + Set<String> names = new HashSet<>(); + + for (VariableElement f : enclosed.values()) { + MarshalledKind kind = kinds.get(f); + + if (kind == null || kind == MarshalledKind.BLOB) + continue; + + Marshalled ann = f.getAnnotation(Marshalled.class); + + if (kind == MarshalledKind.MAP) { + names.add(ann.keys()); + names.add(ann.values()); + } + else + names.add(ann.value()); + } + + return names; + } + + /** Generates Map reconstruction for all map-flavoured {@code @Marshalled} fields. */ + private void appendMarshalledMapFinish(List<String> body) { + for (VariableElement field : enclosed.values()) { + if (kinds.get(field) != MarshalledKind.MAP) + continue; + + Marshalled ann = field.getAnnotation(Marshalled.class); + + VariableElement keysEl = requireEnclosed(enclosed, ann.keys(), "@Marshalled"); + VariableElement valsEl = requireEnclosed(enclosed, ann.values(), "@Marshalled"); + + String mapField = "msg." + field.getSimpleName(); + String keysField = "msg." + ann.keys(); + String valsField = "msg." + ann.values(); + + List<String> code = keysEl.asType().getKind() == TypeKind.ARRAY + ? mapFinishArrayBlock(field, keysEl, valsEl, mapField, keysField, valsField) + : mapFinishCollectionBlock(keysEl, valsEl, mapField, keysField, valsField); + + appendBlock(body, code); + } + } + + /** Generates indexed-loop Map reconstruction for array-backed map-flavoured {@code @Marshalled} fields. */ + private List<String> mapFinishArrayBlock(VariableElement field, VariableElement keysEl, VariableElement valsEl, String mapField, + String keysField, String valsField) { + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null) {", keysField)); + + indent++; + + if (!field.getModifiers().contains(Modifier.FINAL)) { + code.add(indentedLine("%s = U.newHashMap(%s.length);", mapField, keysField)); + code.add(EMPTY); + } + + code.add(indentedLine("for (int i = 0; i < %s.length; i++) {", keysField)); + + indent++; + + code.addAll(mapPutBlock( + ((ArrayType)keysEl.asType()).getComponentType(), + ((ArrayType)valsEl.asType()).getComponentType(), + arrayComponentName(keysEl) + " k = " + keysField + "[i];", + arrayComponentName(valsEl) + " v = " + valsField + "[i];", + mapField)); + + indent--; + + code.add(indentedLine("}")); + code.add(EMPTY); + code.add(indentedLine("%s = null;", keysField)); + code.add(indentedLine("%s = null;", valsField)); + + indent--; + + code.add(indentedLine("}")); + + return code; + } + + /** Generates iterator-based Map reconstruction for collection-backed map-flavoured {@code @Marshalled} fields. */ + private List<String> mapFinishCollectionBlock(VariableElement keysEl, VariableElement valsEl, String mapField, + String keysField, String valsField) { + TypeMirror keyCompType = ((DeclaredType)keysEl.asType()).getTypeArguments().get(0); + TypeMirror valCompType = ((DeclaredType)valsEl.asType()).getTypeArguments().get(0); + + Element keyElem = element(keyCompType); + Element valElem = element(valCompType); + + String keyCompName = keyElem.getSimpleName().toString(); + String valCompName = valElem.getSimpleName().toString(); + + imports.add(((QualifiedNameable)keyElem).getQualifiedName().toString()); + imports.add(((QualifiedNameable)valElem).getQualifiedName().toString()); + imports.add("java.util.Iterator"); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null) {", keysField)); + + indent++; + + code.add(indentedLine("%s = U.newHashMap(%s.size());", mapField, keysField)); + code.add(EMPTY); + code.add(indentedLine("Iterator<%s> keyIter = %s.iterator();", keyCompName, keysField)); + code.add(indentedLine("Iterator<%s> valIter = %s.iterator();", valCompName, valsField)); + code.add(EMPTY); + code.add(indentedLine("while (keyIter.hasNext()) {")); + + indent++; + + code.addAll(mapPutBlock(keyCompType, valCompType, + keyCompName + " k = keyIter.next();", + valCompName + " v = valIter.next();", + mapField)); + + indent--; + + code.add(indentedLine("}")); + code.add(EMPTY); + code.add(indentedLine("%s = null;", keysField)); + code.add(indentedLine("%s = null;", valsField)); + + indent--; + + code.add(indentedLine("}")); + + return code; + } + + /** + * Generates the reconstruction-loop body shared by both map layouts: k/v declarations, + * element unmarshal and {@code map.put}. + */ + private List<String> mapPutBlock(TypeMirror keyCompType, TypeMirror valCompType, String kDecl, String vDecl, String mapField) { + List<String> code = new ArrayList<>(); + + code.add(indentedLine("%s", kDecl)); + code.add(indentedLine("%s", vDecl)); + + List<String> keyUnmarshal = codeFor(keyCompType, "k", MarshalMode.UNMARSHAL); + List<String> valUnmarshal = codeFor(valCompType, "v", MarshalMode.UNMARSHAL); + + if (!keyUnmarshal.isEmpty()) { + code.add(EMPTY); + code.addAll(keyUnmarshal); + } + + if (!valUnmarshal.isEmpty()) { + code.add(EMPTY); + code.addAll(valUnmarshal); + } + + code.add(EMPTY); + code.add(indentedLine("%s.put(k, v);", mapField)); + + return code; + } + + /** Generates key/value array population from the map's entry set. */ + private List<String> arrayMapBody(Marshalled ann, String mapField, String keysField, VariableElement keysEl, String valuesField) { + String compName = arrayComponentName(keysEl); + String valCompName = arrayComponentName(requireEnclosed(enclosed, ann.values(), "@Marshalled")); + + List<String> inner = new ArrayList<>(); + + imports.add("java.util.Map"); + + inner.add(indentedLine("%s = new %s[%s.size()];", keysField, compName, mapField)); + inner.add(indentedLine("%s = new %s[%s.length];", valuesField, valCompName, keysField)); + inner.add(indentedLine("int i = 0;")); + inner.add(indentedLine("for (Map.Entry<?, ?> e : %s.entrySet()) {", mapField)); + + indent++; + + inner.add(indentedLine("%s[i] = (%s)e.getKey();", keysField, compName)); + inner.add(indentedLine("%s[i] = (%s)e.getValue();", valuesField, valCompName)); + inner.add(indentedLine("i++;")); + + indent--; + + inner.add(indentedLine("}")); + + return inner; + } + + /** Generates key/value assignments backed by the map's own {@code keySet()} and {@code values()} views. */ + private List<String> viewBasedMapBody(String keysField, String mapField, String valuesField) { + List<String> inner = new ArrayList<>(); + + inner.add(indentedLine("%s = %s.keySet();", keysField, mapField)); + inner.add(indentedLine("%s = %s.values();", valuesField, mapField)); + + return inner; + } + + /** Marshals each field and appends non-empty results to {@code body}. */ + private void appendFields(List<String> body, List<VariableElement> fields, MarshalMode mode) { + appendFields(body, fields, mode, Set.of()); + } + + /** Marshals each field, skipping names in {@code skip}, and appends non-empty results to {@code body}. */ + private void appendFields(List<String> body, List<VariableElement> fields, MarshalMode mode, Set<String> skip) { + for (VariableElement field : fields) { + if (skip.contains(field.getSimpleName().toString())) + continue; + + List<String> result = codeFor(field.asType(), fieldAccessor(field), mode); + + if (!result.isEmpty()) + appendBlock(body, result); + } + } + + /** Returns generated marshal/unmarshal code lines for field of type {@code t}, or empty if none needed. */ + private List<String> codeFor(TypeMirror t, String accessor, MarshalMode mode) { + if (t.getKind() == TypeKind.ARRAY) { + TypeMirror comp = ((ArrayType)t).getComponentType(); + + return comp.getKind() == TypeKind.DECLARED ? marshallArray(comp, accessor, mode) : List.of(); + } + + if (t.getKind() == TypeKind.DECLARED || t.getKind() == TypeKind.TYPEVAR) { + if (isMessage(t)) + return isNonMarshallable(t) ? List.of() : marshallMessage(accessor, mode); + if (isCacheObject(t)) + return marshallCacheObject(accessor, mode); + if (isMap(t)) + return marshallMap((DeclaredType)t, accessor, mode); + if (isCollection(t)) + return marshallCollection((DeclaredType)t, accessor, mode); + } + + return List.of(); + } + + /** + * Generates a null-guarded {@code MessageMarshalling.marshal/unmarshal} call. Loop-nested calls go through the + * overloads taking the pre-resolved {@code msgFactory} local (see {@link #prependMsgFactoryResolution}), so the + * factory is not re-resolved from the context on every element. + */ + private List<String> marshallMessage(String accessor, MarshalMode mode) { + imports.add("org.apache.ignite.internal.managers.communication.MessageMarshalling"); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null)", accessor)); + + indent++; + + if (loopDepth > 0) { + usesMsgFactory = true; + + code.add(mode == MarshalMode.MARSHAL + ? indentedLine("MessageMarshalling.marshal(msgFactory, %s, kctx, ctx);", accessor) + : indentedLine("MessageMarshalling.unmarshal(msgFactory, %s, kctx, ctx, clsLdr);", accessor)); + } + else { + code.add(mode == MarshalMode.MARSHAL + ? indentedLine("MessageMarshalling.marshal(%s, kctx, ctx);", accessor) + : indentedLine("MessageMarshalling.unmarshal(%s, kctx, ctx, clsLdr);", accessor)); + } + + indent--; + + return code; + } + + /** Generates a null-and-ctx-guarded {@code marshal/unmarshal} call on a {@code CacheObject} (marshal or cache-aware unmarshal only). */ + private List<String> marshallCacheObject(String accessor, MarshalMode mode) { + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null && ctx != null)", accessor)); + + indent++; + + code.add(mode == MarshalMode.MARSHAL + ? indentedLine("%s.marshal(ctx);", accessor) + : indentedLine("%s.unmarshal(ctx, clsLdr);", accessor)); + + indent--; + + return code; + } + + /** Generates a null-guarded for-each loop over the array's elements. */ + private List<String> marshallArray(TypeMirror comp, String accessor, MarshalMode mode) { + Element elem = ((DeclaredType)comp).asElement(); + + indent++; + + List<String> loopCode = forLoop(elem.getSimpleName().toString(), comp, accessor, mode); + + indent--; + + if (!loopCode.isEmpty()) + imports.add(((QualifiedNameable)elem).getQualifiedName().toString()); + + return wrapNullGuarded(accessor, loopCode); + } + + /** Generates a null-guarded for-each loop over the collection's elements. */ + private List<String> marshallCollection(DeclaredType t, String accessor, MarshalMode mode) { + TypeMirror arg = t.getTypeArguments().get(0); + + if (arg.getKind() != TypeKind.DECLARED && arg.getKind() != TypeKind.TYPEVAR) + return List.of(); + + Element elem = element(arg); + + String typeName = elem.getSimpleName().toString(); + + indent++; + + List<String> loopCode = forLoop(typeName, arg, "(Collection<? extends " + typeName + ">)" + accessor, mode); + + indent--; + + if (!loopCode.isEmpty()) { + imports.add(((QualifiedNameable)elem).getQualifiedName().toString()); + imports.add("java.util.Collection"); + } + + return wrapNullGuarded(accessor, loopCode); + } + + /** Iterates {@code keySet()} then {@code values()}, wrapping both loops in a null-guard. */ + private List<String> marshallMap(DeclaredType t, String accessor, MarshalMode mode) { + List<? extends TypeMirror> args = t.getTypeArguments(); + + indent++; + + List<String> combined = new ArrayList<>(); + + for (int i = 0; i < 2; i++) { + TypeMirror elemType = args.get(i); + + if (elemType.getKind() != TypeKind.DECLARED && elemType.getKind() != TypeKind.TYPEVAR) + continue; + + Element elem = element(elemType); + + String typeName = elem.getSimpleName().toString(); + String collection = i == 0 ? "keySet" : "values"; + String iterable = "((Collection<? extends " + typeName + ">)" + accessor + "." + collection + "())"; + + List<String> loopCode = forLoop(typeName, elemType, iterable, mode); + + if (loopCode.isEmpty()) + continue; + + imports.add(((QualifiedNameable)elem).getQualifiedName().toString()); + imports.add("java.util.Collection"); + + combined.addAll(loopCode); + } + + indent--; + + return wrapNullGuarded(accessor, combined); + } + + /** Returns empty if {@code elemType} requires no marshalling; otherwise returns a for-each loop over {@code iterable}. */ + private List<String> forLoop(String typeName, TypeMirror elemType, String iterable, MarshalMode mode) { + String el = loopDepth == 0 ? "e" : "e" + loopDepth; + + loopDepth++; + indent++; + + List<String> inner = codeFor(elemType, el, mode); + + indent--; + loopDepth--; + + if (inner.isEmpty()) + return List.of(); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("for (%s %s : %s) {", typeName, el, iterable)); + + code.addAll(inner); + + code.add(indentedLine("}")); + + return code; + } + + /** Prefixes {@code body} with the {@code msgFactory} resolution line when a loop-nested facade call was emitted. */ + private void prependMsgFactoryResolution(List<String> body) { + if (!usesMsgFactory) + return; + + imports.add("org.apache.ignite.internal.managers.communication.IgniteMessageFactory"); + + body.add(0, EMPTY); + body.add(0, indentedLine("IgniteMessageFactory msgFactory = (IgniteMessageFactory)kctx.messageFactory();")); + } + + /** Returns empty if {@code inner} is empty; otherwise wraps {@code inner} in a null-guard on {@code nullGuard}. */ + private List<String> wrapNullGuarded(String nullGuard, List<String> inner) { + if (inner.isEmpty()) + return List.of(); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null) {", nullGuard)); + + code.addAll(inner); + + code.add(indentedLine("}")); + + return code; + } + + /** + * Returns the {@code CacheObjectContext ctx} resolution line for the current message type. Cache messages resolve + * via the cache, group messages via the cache group — the group's context outlives the stop of individual caches, + * so cache objects still unmarshal while a cache (group) is being destroyed. + */ + private String ctxResolutionLine() { + if (isCacheIdAwareMessage(type)) + return indentedLine("CacheObjectContext ctx = cacheObjCtx != null ? cacheObjCtx : " + + "kctx.cache().context().cacheObjectContext(msg.cacheId());"); + else if (isCacheGroupIdMessage(type)) + return indentedLine("CacheObjectContext ctx = cacheObjCtx != null ? cacheObjCtx : " + + "kctx.cache().cacheGroup(msg.groupId()) == null ? null : " + + "kctx.cache().cacheGroup(msg.groupId()).cacheObjectContext();"); + else + return indentedLine("CacheObjectContext ctx = cacheObjCtx;"); + } + + /** Returns {@code true} if any field requires {@code ctx} in generated marshal/unmarshal code. */ + private boolean needsCtx(List<VariableElement> fields) { + return fields.stream().anyMatch(f -> needsCtxType(f.asType())); + } + + /** + * Returns whether the {@code @Order} fields of {@code msgType} need a cache object context to unmarshal. Such a + * message must not be a {@code @NioField}: its {@code unmarshalNio} runs on the NIO thread, which has no context. + * A type with no fields to inspect (e.g. a type variable) is conservatively assumed to need the context. + */ + private boolean nestedNeedsCtx(TypeMirror type) { + Element el = env.getTypeUtils().asElement(type); + + if (!(el instanceof TypeElement)) + return true; + + return SystemViewRowAttributeWalkerProcessor.superclasses(env, (TypeElement)el) + .flatMap(c -> ElementFilter.fieldsIn(c.getEnclosedElements()).stream()) + .filter(f -> f.getAnnotation(Order.class) != null) + .anyMatch(f -> needsCtxType(f.asType())); + } + + /** Returns {@code true} if type {@code t} (or its element/key/value types) requires {@code ctx}. */ + private boolean needsCtxType(TypeMirror t) { + if (t.getKind() == TypeKind.ARRAY) + return needsCtxType(((ArrayType)t).getComponentType()); + + if (t.getKind() == TypeKind.DECLARED || t.getKind() == TypeKind.TYPEVAR) { + if (isMessage(t)) + return !isNonMarshallable(t); + + if (isCacheObject(t)) + return true; + + if (isMap(t)) { + List<? extends TypeMirror> args = ((DeclaredType)t).getTypeArguments(); + return needsCtxType(args.get(0)) || needsCtxType(args.get(1)); + } + + if (isCollection(t)) { + List<? extends TypeMirror> args = ((DeclaredType)t).getTypeArguments(); + return needsCtxType(args.get(0)); + } + } + + return false; + } + + /** */ + private boolean isMessage(TypeMirror type) { + return assignableFrom(type, msgType); + } + + /** */ + private boolean isCacheObject(TypeMirror type) { + return assignableFrom(type, cacheObjType); + } + + /** Returns {@code true} if {@code type} (erased) is assignable to {@code java.util.Map}. */ + private boolean isMap(TypeMirror type) { + return assignableFrom(erasedType(type), mapType); + } + + /** Returns {@code true} if {@code type} (erased) is assignable to {@code java.util.Collection}. */ + private boolean isCollection(TypeMirror type) { + return assignableFrom(erasedType(type), colType); + } + + /** */ + private boolean isNonMarshallableMessage(TypeElement te) { + return isNonMarshallable(te.asType()); + } + + /** Recursion skip for such fields is subtype-safe: subclasses inherit the {@code NonMarshallableMessage} marker. */ + private boolean isNonMarshallable(TypeMirror t) { + return assignableFrom(t, nonMarshallableType); + } + + /** */ + private boolean isCacheGroupIdMessage(TypeElement te) { + return assignableFrom(te.asType(), cacheGrpIdMsgType); + } + + /** */ + private static boolean isNioField(VariableElement field) { + return field.getAnnotation(NioField.class) != null; + } + + /** Marshalling flavour of a {@code @Marshalled} field, told apart by the shape of its companion wire field(s). */ + private enum MarshalledKind { + /** {@code byte[]} companion: the whole object is a single marshaller blob. */ + BLOB, + + /** {@code Message[]} companion: per-element {@code Message} serialization, the collection is rebuilt on unmarshal. */ + ELEMENTS, + + /** {@code Collection<byte[]>} companion: per-element marshaller blobs, each element keeping its own class loader. */ + ELEMENT_BLOBS, + + /** Two companions ({@code keys()}/{@code values()}): a {@code Map} serialized as parallel wire fields. */ + MAP + } + + /** + * @return the flavour of {@code field}'s {@code @Marshalled}, or {@code null} when the field is not annotated. + * Called once per field when building {@link #kinds}; look the kind up there instead. + */ + private @Nullable MarshalledKind marshalledKind(VariableElement field) { + Marshalled ann = field.getAnnotation(Marshalled.class); + + if (ann == null) + return null; + + boolean map = !ann.keys().isEmpty() || !ann.values().isEmpty(); + + if (map == !ann.value().isEmpty() || (map && (ann.keys().isEmpty() || ann.values().isEmpty()))) { + env.getMessager().printMessage(Diagnostic.Kind.ERROR, + "@Marshalled must set either value() or both keys() and values()", field); + + return null; + } + + if (map) + return MarshalledKind.MAP; + + TypeMirror wire = requireEnclosed(enclosed, ann.value(), "@Marshalled").asType(); + + if (wire.getKind() == TypeKind.ARRAY) { + return ((ArrayType)wire).getComponentType().getKind() == TypeKind.BYTE + ? MarshalledKind.BLOB + : MarshalledKind.ELEMENTS; + } + + return MarshalledKind.ELEMENT_BLOBS; + } + + /** Returns the enclosed field named {@code name}, or throws if absent. */ + private VariableElement requireEnclosed(Map<String, VariableElement> enclosed, String name, String annotationName) { + VariableElement el = enclosed.get(name); + + if (el == null) + throw new IllegalStateException(annotationName + " companion field '" + name + "' not found in " + type); + + return el; + } + + /** Iterates all {@code @Marshalled} fields and applies {@code codeGen(bytesAccessor, objAccessor)} to each. */ + private void forEachMarshalled(BiFunction<String, String, List<String>> codeGen, List<String> body) { + for (VariableElement field : enclosed.values()) { + if (kinds.get(field) != MarshalledKind.BLOB) + continue; + + Marshalled ann = field.getAnnotation(Marshalled.class); + + appendBlock(body, codeGen.apply("msg." + ann.value(), "msg." + field.getSimpleName())); + } + } + + /** Returns the element for {@code t}; for a type variable, uses its upper bound. */ + private Element element(TypeMirror t) { Review Comment: ```suggestion return t.getKind() == TypeKind.DECLARED ? ((DeclaredType)t).asElement() : ((DeclaredType)((TypeVariable)t).getUpperBound()).asElement(); ``` ########## modules/codegen/src/main/java/org/apache/ignite/internal/MessageMarshallerGenerator.java: ########## @@ -0,0 +1,1180 @@ +/* + * 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.io.IOException; +import java.io.StringWriter; +import java.io.Writer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.function.BiFunction; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.QualifiedNameable; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.ArrayType; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeKind; +import javax.lang.model.type.TypeMirror; +import javax.lang.model.type.TypeVariable; +import javax.lang.model.util.ElementFilter; +import javax.tools.Diagnostic; +import org.apache.ignite.internal.systemview.SystemViewRowAttributeWalkerProcessor; +import org.jetbrains.annotations.Nullable; + +import static org.apache.ignite.internal.MessageProcessor.CACHE_OBJECT_CLS; +import static org.apache.ignite.internal.MessageProcessor.KEY_CACHE_OBJECT_CLS; +import static org.apache.ignite.internal.MessageProcessor.MARSHALLABLE_MESSAGE_INTERFACE; +import static org.apache.ignite.internal.MessageProcessor.MESSAGE_INTERFACE; +import static org.apache.ignite.internal.MessageProcessor.NON_MARSHALLABLE_MESSAGE_INTERFACE; + +/** + * Generates {@code *Marshaller} classes for {@code Message} types that are not {@code NonMarshallableMessage}. + */ +public class MessageMarshallerGenerator extends MessageGenerator { + /** Accumulated source lines for all generated marshal/unmarshal methods. */ + private final List<String> marshall = new ArrayList<>(); + + /** */ + private final TypeMirror marshallableMsgType; + + /** */ + private final TypeMirror msgType; + + /** */ + private final TypeMirror cacheObjType; + + /** */ + private final TypeMirror nonMarshallableType; + + /** */ + private final TypeMirror cacheGrpIdMsgType; + + /** */ + private final TypeMirror mapType; + + /** */ + private final TypeMirror colType; + + /** */ + private boolean marshallable; + + /** */ + private boolean hasMarshalled; + + /** Whether any generated method got a non-empty body; a marshaller without one is skipped entirely. */ + private boolean hasStatements; + + /** Enclosed fields of the currently processed type. Computed once per {@link #generateBody} call. */ + private Map<String, VariableElement> enclosed; + + /** {@link MarshalledKind} of each {@code @Marshalled} enclosed field. Computed once per {@link #generateBody} call. */ + private final Map<VariableElement, MarshalledKind> kinds = new HashMap<>(); + + /** Nesting depth of the current marshal for-loop; names loop variables {@code e}, {@code e1}, {@code e2}… */ + private int loopDepth; + + /** Whether the currently generated method emitted a loop-nested facade call and so needs the {@code msgFactory} local. */ + private boolean usesMsgFactory; + + /** */ + MessageMarshallerGenerator(ProcessingEnvironment env) { + super(env); + + marshallableMsgType = type(MARSHALLABLE_MESSAGE_INTERFACE); + msgType = type(MESSAGE_INTERFACE); + cacheObjType = type(CACHE_OBJECT_CLS); + nonMarshallableType = type(NON_MARSHALLABLE_MESSAGE_INTERFACE); + cacheGrpIdMsgType = type("org.apache.ignite.internal.processors.cache.GridCacheGroupIdMessage"); + mapType = type("java.util.Map"); + colType = type("java.util.Collection"); + } + + /** {@inheritDoc} */ + @Override String typeSuffix() { + return "Marshaller"; + } + + /** {@inheritDoc} */ + @Override boolean shouldSkip(TypeElement type, List<VariableElement> fields) { + return isNonMarshallableMessage(type); + } + + /** {@inheritDoc} */ + @Override void generateBody(List<VariableElement> fields) throws Exception { + enclosed = enclosedFields(); + + for (VariableElement f : enclosed.values()) { + MarshalledKind kind = marshalledKind(f); + + if (kind != null) + kinds.put(f, kind); + } + + marshallable = marshallableMsgType != null && assignableFrom(type.asType(), marshallableMsgType); + hasMarshalled = kinds.values().stream().anyMatch(k -> k == MarshalledKind.BLOB || k == MarshalledKind.ELEMENT_BLOBS); + + generateMarshalMethod(fields); + generateUnmarshalMethods(fields); + } + + /** {@inheritDoc} */ + @Override String buildClassCode(String marshallerClsName) throws IOException { + if (!hasStatements) + return null; + + try (Writer writer = new StringWriter()) { + imports.add(type.toString()); + imports.add("org.apache.ignite.plugin.extensions.communication.MessageMarshaller"); + + if (marshallable || hasMarshalled) + imports.add("org.apache.ignite.marshaller.Marshaller"); + + writeClassHeader(writer, "MessageMarshaller", marshallerClsName); + + writer.write(" {" + NL); + + writeConstructor(writer, marshallerClsName); + + for (String line : marshall) + writer.write(line + NL); + + writer.write("}"); + + return writer.toString(); + } + } + + /** Writes the {@code marshaller} field and the constructor initializing it, when the marshaller is needed. */ + private void writeConstructor(Writer writer, String marshallerClsName) throws IOException { + if (!marshallable && !hasMarshalled) + return; + + writer.write(indentedLine(METHOD_JAVADOC)); + writer.write(NL); + writer.write(indentedLine("private final Marshaller marshaller;")); + writer.write(NL + NL); + + writer.write(indentedLine(METHOD_JAVADOC)); + writer.write(NL); + writer.write(indentedLine("public " + marshallerClsName + "(Marshaller marshaller) {")); + writer.write(NL); + + indent++; + + writer.write(indentedLine("this.marshaller = marshaller;")); + writer.write(NL); + + indent--; + + writer.write(indentedLine("}")); + writer.write(NL + NL); + } + + /** Generates the {@code marshal} method body and appends it to {@link #marshall}. */ + private void generateMarshalMethod(List<VariableElement> orderedFields) { + imports.add("org.apache.ignite.IgniteCheckedException"); + imports.add("org.apache.ignite.internal.GridKernalContext"); + imports.add("org.apache.ignite.internal.processors.cache.CacheObjectContext"); + + String signature = "marshal(" + simpleNameWithGeneric(type) + " msg, GridKernalContext kctx, CacheObjectContext cacheObjCtx)"; + + hasStatements |= emitMethod(marshall, signature, body -> { + usesMsgFactory = false; + + if (needsCtx(orderedFields)) + appendBlock(body, List.of(ctxResolutionLine())); + + appendMarshalledFieldsPrepare(body); + appendMarshalledPrepare(body); + + if (marshallable) + appendBlock(body, List.of(indentedLine("msg.marshal(marshaller);"))); + + appendFields(body, orderedFields, MarshalMode.MARSHAL); + + prependMsgFactoryResolution(body); + }); + } + + /** Generates all {@code unmarshal} overloads and appends them to {@link #marshall}. */ + private void generateUnmarshalMethods(List<VariableElement> orderedFields) { + List<VariableElement> nioFields = new ArrayList<>(); + List<VariableElement> workerFields = new ArrayList<>(); + + for (VariableElement f : orderedFields) { + boolean nioField = isNioField(f); + + if (nioField && isMessage(f.asType()) && !nestedNeedsCtx(f.asType())) + nioFields.add(f); + else { + if (nioField && !isMessage(f.asType())) Review Comment: Brackets ########## modules/codegen/src/main/java/org/apache/ignite/internal/MessageMarshallerGenerator.java: ########## @@ -0,0 +1,1180 @@ +/* + * 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.io.IOException; +import java.io.StringWriter; +import java.io.Writer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.function.BiFunction; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.QualifiedNameable; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.ArrayType; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeKind; +import javax.lang.model.type.TypeMirror; +import javax.lang.model.type.TypeVariable; +import javax.lang.model.util.ElementFilter; +import javax.tools.Diagnostic; +import org.apache.ignite.internal.systemview.SystemViewRowAttributeWalkerProcessor; +import org.jetbrains.annotations.Nullable; + +import static org.apache.ignite.internal.MessageProcessor.CACHE_OBJECT_CLS; +import static org.apache.ignite.internal.MessageProcessor.KEY_CACHE_OBJECT_CLS; +import static org.apache.ignite.internal.MessageProcessor.MARSHALLABLE_MESSAGE_INTERFACE; +import static org.apache.ignite.internal.MessageProcessor.MESSAGE_INTERFACE; +import static org.apache.ignite.internal.MessageProcessor.NON_MARSHALLABLE_MESSAGE_INTERFACE; + +/** + * Generates {@code *Marshaller} classes for {@code Message} types that are not {@code NonMarshallableMessage}. + */ +public class MessageMarshallerGenerator extends MessageGenerator { + /** Accumulated source lines for all generated marshal/unmarshal methods. */ + private final List<String> marshall = new ArrayList<>(); + + /** */ + private final TypeMirror marshallableMsgType; + + /** */ + private final TypeMirror msgType; + + /** */ + private final TypeMirror cacheObjType; + + /** */ + private final TypeMirror nonMarshallableType; + + /** */ + private final TypeMirror cacheGrpIdMsgType; + + /** */ + private final TypeMirror mapType; + + /** */ + private final TypeMirror colType; + + /** */ + private boolean marshallable; + + /** */ + private boolean hasMarshalled; + + /** Whether any generated method got a non-empty body; a marshaller without one is skipped entirely. */ + private boolean hasStatements; + + /** Enclosed fields of the currently processed type. Computed once per {@link #generateBody} call. */ + private Map<String, VariableElement> enclosed; + + /** {@link MarshalledKind} of each {@code @Marshalled} enclosed field. Computed once per {@link #generateBody} call. */ + private final Map<VariableElement, MarshalledKind> kinds = new HashMap<>(); + + /** Nesting depth of the current marshal for-loop; names loop variables {@code e}, {@code e1}, {@code e2}… */ + private int loopDepth; + + /** Whether the currently generated method emitted a loop-nested facade call and so needs the {@code msgFactory} local. */ + private boolean usesMsgFactory; + + /** */ + MessageMarshallerGenerator(ProcessingEnvironment env) { + super(env); + + marshallableMsgType = type(MARSHALLABLE_MESSAGE_INTERFACE); + msgType = type(MESSAGE_INTERFACE); + cacheObjType = type(CACHE_OBJECT_CLS); + nonMarshallableType = type(NON_MARSHALLABLE_MESSAGE_INTERFACE); + cacheGrpIdMsgType = type("org.apache.ignite.internal.processors.cache.GridCacheGroupIdMessage"); + mapType = type("java.util.Map"); + colType = type("java.util.Collection"); + } + + /** {@inheritDoc} */ + @Override String typeSuffix() { + return "Marshaller"; + } + + /** {@inheritDoc} */ + @Override boolean shouldSkip(TypeElement type, List<VariableElement> fields) { + return isNonMarshallableMessage(type); + } + + /** {@inheritDoc} */ + @Override void generateBody(List<VariableElement> fields) throws Exception { + enclosed = enclosedFields(); + + for (VariableElement f : enclosed.values()) { + MarshalledKind kind = marshalledKind(f); + + if (kind != null) + kinds.put(f, kind); + } + + marshallable = marshallableMsgType != null && assignableFrom(type.asType(), marshallableMsgType); + hasMarshalled = kinds.values().stream().anyMatch(k -> k == MarshalledKind.BLOB || k == MarshalledKind.ELEMENT_BLOBS); + + generateMarshalMethod(fields); + generateUnmarshalMethods(fields); + } + + /** {@inheritDoc} */ + @Override String buildClassCode(String marshallerClsName) throws IOException { + if (!hasStatements) + return null; + + try (Writer writer = new StringWriter()) { + imports.add(type.toString()); + imports.add("org.apache.ignite.plugin.extensions.communication.MessageMarshaller"); + + if (marshallable || hasMarshalled) + imports.add("org.apache.ignite.marshaller.Marshaller"); + + writeClassHeader(writer, "MessageMarshaller", marshallerClsName); + + writer.write(" {" + NL); + + writeConstructor(writer, marshallerClsName); + + for (String line : marshall) + writer.write(line + NL); + + writer.write("}"); + + return writer.toString(); + } + } + + /** Writes the {@code marshaller} field and the constructor initializing it, when the marshaller is needed. */ + private void writeConstructor(Writer writer, String marshallerClsName) throws IOException { + if (!marshallable && !hasMarshalled) + return; + + writer.write(indentedLine(METHOD_JAVADOC)); + writer.write(NL); + writer.write(indentedLine("private final Marshaller marshaller;")); + writer.write(NL + NL); + + writer.write(indentedLine(METHOD_JAVADOC)); + writer.write(NL); + writer.write(indentedLine("public " + marshallerClsName + "(Marshaller marshaller) {")); + writer.write(NL); + + indent++; + + writer.write(indentedLine("this.marshaller = marshaller;")); + writer.write(NL); + + indent--; + + writer.write(indentedLine("}")); + writer.write(NL + NL); + } + + /** Generates the {@code marshal} method body and appends it to {@link #marshall}. */ + private void generateMarshalMethod(List<VariableElement> orderedFields) { + imports.add("org.apache.ignite.IgniteCheckedException"); + imports.add("org.apache.ignite.internal.GridKernalContext"); + imports.add("org.apache.ignite.internal.processors.cache.CacheObjectContext"); + + String signature = "marshal(" + simpleNameWithGeneric(type) + " msg, GridKernalContext kctx, CacheObjectContext cacheObjCtx)"; + + hasStatements |= emitMethod(marshall, signature, body -> { + usesMsgFactory = false; + + if (needsCtx(orderedFields)) + appendBlock(body, List.of(ctxResolutionLine())); + + appendMarshalledFieldsPrepare(body); + appendMarshalledPrepare(body); + + if (marshallable) + appendBlock(body, List.of(indentedLine("msg.marshal(marshaller);"))); + + appendFields(body, orderedFields, MarshalMode.MARSHAL); + + prependMsgFactoryResolution(body); + }); + } + + /** Generates all {@code unmarshal} overloads and appends them to {@link #marshall}. */ + private void generateUnmarshalMethods(List<VariableElement> orderedFields) { + List<VariableElement> nioFields = new ArrayList<>(); + List<VariableElement> workerFields = new ArrayList<>(); + + for (VariableElement f : orderedFields) { + boolean nioField = isNioField(f); + + if (nioField && isMessage(f.asType()) && !nestedNeedsCtx(f.asType())) + nioFields.add(f); + else { + if (nioField && !isMessage(f.asType())) + env.getMessager().printMessage(Diagnostic.Kind.ERROR, + "@NioField has no effect on non-Message field '" + f.getSimpleName() + "' of type " + f.asType(), f); + else if (nioField) + env.getMessager().printMessage(Diagnostic.Kind.ERROR, + "@NioField field '" + f.getSimpleName() + "' of type " + f.asType() + " needs a cache object " + + "context to unmarshal, but the NIO thread has none; only context-free messages may be @NioField", f); + + workerFields.add(f); + } + } + + // U is referenced only by @Marshalled handling. + boolean usesU = enclosed.values().stream().anyMatch(f -> f.getAnnotation(Marshalled.class) != null); + + if (usesU) + imports.add("org.apache.ignite.internal.util.typedef.internal.U"); + + String msgParam = simpleNameWithGeneric(type) + " msg, GridKernalContext kctx"; + + generateUnmarshalMethod(msgParam + ", CacheObjectContext cacheObjCtx, ClassLoader clsLdr", workerFields); + + if (!nioFields.isEmpty()) + generateUnmarshalNioMethod(msgParam, nioFields); + } + + /** Generates the cache-aware {@code unmarshal} overload: the full field set, with cache context and deployment class loader. */ + private void generateUnmarshalMethod(String params, List<VariableElement> fields) { + hasStatements |= emitMethod(marshall, "unmarshal(" + params + ")", body -> { + usesMsgFactory = false; + + Set<String> wireFieldSkip = marshalledWireFieldsToSkip(); + + if (needsCtx(fields) || !wireFieldSkip.isEmpty()) + appendBlock(body, List.of(ctxResolutionLine())); + + appendFields(body, fields, MarshalMode.UNMARSHAL, wireFieldSkip); + + if (marshallable) + appendBlock(body, List.of(indentedLine("msg.unmarshal(marshaller, clsLdr);"))); + + appendMarshalledFinish(body); + + appendMarshalledElementsFinish(body); + appendMarshalledMapFinish(body); + appendMarshalledElementBlobsFinish(body); + + prependMsgFactoryResolution(body); + }); + } + + /** Generates the {@code unmarshalNio} method for NIO-eligible {@code @Message} fields. */ + private void generateUnmarshalNioMethod(String params, List<VariableElement> nioFields) { + hasStatements |= emitMethod(marshall, "unmarshalNio(" + params + ")", body -> { + for (VariableElement f : nioFields) + appendBlock(body, unmarshalNioField(fieldAccessor(f))); + }); + } + + /** Cache-free unmarshal of a {@code @NioField} message field on the NIO thread (no cache context available). */ + private List<String> unmarshalNioField(String accessor) { + imports.add("org.apache.ignite.internal.managers.communication.MessageMarshalling"); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null)", accessor)); + + indent++; + + code.add(indentedLine("MessageMarshalling.unmarshal(%s, kctx);", accessor)); + + indent--; + + return code; + } + + /** Generates logical→wire conversions for the element-, blob-list- and map-flavoured {@code @Marshalled} fields. */ + private void appendMarshalledFieldsPrepare(List<String> body) { + for (VariableElement field : enclosed.values()) { + appendCollectionPrepare(body, field); + appendMapPrepare(body, field); + appendObjectsPrepare(body, field); + } + } + + /** Generates the {@code Collection<byte[]>} build-up for a per-element-blobs {@code @Marshalled} field in marshal. */ + private void appendObjectsPrepare(List<String> body, VariableElement field) { + if (kinds.get(field) != MarshalledKind.ELEMENT_BLOBS) + return; + + Marshalled ann = field.getAnnotation(Marshalled.class); + + String objField = "msg." + field.getSimpleName(); + String bytesField = "msg." + ann.value(); + + imports.add("java.util.ArrayList"); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null && %s == null) {", objField, bytesField)); + + indent++; + + code.add(indentedLine("%s = new ArrayList<>(%s.size());", bytesField, objField)); + code.add(EMPTY); + code.add(indentedLine("for (Object e : %s)", objField)); + + indent++; + + code.add(indentedLine("%s.add(U.marshal(marshaller, e));", bytesField)); + + indent--; + indent--; + + code.add(indentedLine("}")); + + appendBlock(body, code); + } + + /** Appends a {@code toArray} assignment for a per-element {@code @Marshalled} field, if present. */ + private void appendCollectionPrepare(List<String> body, VariableElement field) { + if (kinds.get(field) != MarshalledKind.ELEMENTS) + return; + + Marshalled ann = field.getAnnotation(Marshalled.class); + + String colField = "msg." + field.getSimpleName(); + String arrField = "msg." + ann.value(); + String compName = arrayComponentName(requireEnclosed(enclosed, ann.value(), "@Marshalled")); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null && %s == null)", colField, arrField)); + + indent++; + + code.add(indentedLine("%s = %s.toArray(new %s[0]);", arrField, colField, compName)); + + indent--; + + appendBlock(body, code); + } + + /** Appends key/value array assignments for a map-flavoured {@code @Marshalled} field, if present. */ + private void appendMapPrepare(List<String> body, VariableElement field) { + if (kinds.get(field) != MarshalledKind.MAP) + return; + + Marshalled ann = field.getAnnotation(Marshalled.class); + + String mapField = "msg." + field.getSimpleName(); + String keysField = "msg." + ann.keys(); + String valuesField = "msg." + ann.values(); + VariableElement keysEl = requireEnclosed(enclosed, ann.keys(), "@Marshalled"); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null && %s == null) {", mapField, keysField)); + + indent++; + + code.addAll(keysEl.asType().getKind() == TypeKind.ARRAY + ? arrayMapBody(ann, mapField, keysField, keysEl, valuesField) + : viewBasedMapBody(keysField, mapField, valuesField)); + + indent--; + + code.add(indentedLine("}")); + + appendBlock(body, code); + } + + /** Generates {@code U.marshal} calls for all {@code @Marshalled} fields in marshal. */ + private void appendMarshalledPrepare(List<String> body) { + forEachMarshalled((bytesAcc, objAcc) -> { + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null && %s == null)", objAcc, bytesAcc)); + + indent++; + + code.add(indentedLine("%s = U.marshal(marshaller, %s);", bytesAcc, objAcc)); + + indent--; + + return code; + }, body); + } + + /** Generates {@code U.unmarshal} calls for all {@code @Marshalled} fields in the cache-aware unmarshal. */ + private void appendMarshalledFinish(List<String> body) { + forEachMarshalled((bytesAcc, objAcc) -> { + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null) {", bytesAcc)); + + indent++; + + code.add(indentedLine("%s = U.unmarshal(marshaller, %s, clsLdr);", objAcc, bytesAcc)); + code.add(EMPTY); + + // Drop the serialized cache once the object is restored: keeping both the deserialized value and its bytes + // on every received message doubles retained memory (e.g. topology history nodes) and can exhaust the heap. + code.add(indentedLine("%s = null;", bytesAcc)); + + indent--; + + code.add(indentedLine("}")); + + return code; + }, body); + } + + /** Generates Set reconstruction for all {@link MarshalledKind#ELEMENTS} {@code @Marshalled} fields. */ + private void appendMarshalledElementsFinish(List<String> body) { + for (VariableElement field : enclosed.values()) { + if (kinds.get(field) != MarshalledKind.ELEMENTS) + continue; + + Marshalled colAnn = field.getAnnotation(Marshalled.class); + + String colField = "msg." + field.getSimpleName(); + String arrField = "msg." + colAnn.value(); + VariableElement wireField = requireEnclosed(enclosed, colAnn.value(), "@Marshalled"); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null) {", arrField)); + + indent++; + + code.add(indentedLine("%s = U.newHashSet(%s.length);", colField, arrField)); + code.add(EMPTY); + code.addAll(collectionFinishForBlock(wireField, colField, arrField, field.getSimpleName().toString())); + code.add(EMPTY); + code.add(indentedLine("%s = null;", arrField)); + + indent--; + + code.add(indentedLine("}")); + + appendBlock(body, code); + } + } + + /** Generates Collection reconstruction for {@link MarshalledKind#ELEMENT_BLOBS} {@code @Marshalled} fields (cache-aware pass only). */ + private void appendMarshalledElementBlobsFinish(List<String> body) { + for (VariableElement field : enclosed.values()) { + if (kinds.get(field) != MarshalledKind.ELEMENT_BLOBS) + continue; + + Marshalled ann = field.getAnnotation(Marshalled.class); + + String objField = "msg." + field.getSimpleName(); + String bytesField = "msg." + ann.value(); + + imports.add("java.util.ArrayList"); + imports.add("java.util.Map"); + imports.add(KEY_CACHE_OBJECT_CLS); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null) {", bytesField)); + + indent++; + + code.add(indentedLine("%s = new ArrayList<>(%s.size());", objField, bytesField)); + code.add(EMPTY); + code.add(indentedLine("for (byte[] e : %s) {", bytesField)); + + indent++; + + code.add(indentedLine("Object o = U.unmarshal(marshaller, e, clsLdr);")); + code.add(EMPTY); + code.add(indentedLine("if (o instanceof Map.Entry) {")); + + indent++; + + code.add(indentedLine("Object key = ((Map.Entry<?, ?>)o).getKey();")); + code.add(EMPTY); + code.add(indentedLine("if (key instanceof KeyCacheObject)")); + + indent++; + + code.add(indentedLine("((KeyCacheObject)key).unmarshal(ctx, clsLdr);")); + + indent--; + indent--; + + code.add(indentedLine("}")); + code.add(EMPTY); + code.add(indentedLine("%s.add(o);", objField)); + + indent--; + + code.add(indentedLine("}")); + code.add(EMPTY); + code.add(indentedLine("%s = null;", bytesField)); + + indent--; + + code.add(indentedLine("}")); + + appendBlock(body, code); + } + } + + /** Generates the {@code for} loop body: per-element unmarshal + try/catch add into the collection. */ + private List<String> collectionFinishForBlock(VariableElement wireField, String colField, String arrField, String fieldName) { + String compName = arrayComponentName(wireField); + TypeMirror compType = ((ArrayType)wireField.asType()).getComponentType(); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("for (%s e : %s) {", compName, arrField)); + + indent++; + + code.addAll(codeFor(compType, "e", MarshalMode.UNMARSHAL)); + code.add(EMPTY); + code.add(indentedLine("%s.add(e);", colField)); + + indent--; + + code.add(indentedLine("}")); + + return code; + } + + /** Returns names of wire fields skipped by {@link #appendFields} in UNMARSHAL mode. */ + private Set<String> marshalledWireFieldsToSkip() { + Set<String> names = new HashSet<>(); + + for (VariableElement f : enclosed.values()) { + MarshalledKind kind = kinds.get(f); + + if (kind == null || kind == MarshalledKind.BLOB) + continue; + + Marshalled ann = f.getAnnotation(Marshalled.class); + + if (kind == MarshalledKind.MAP) { + names.add(ann.keys()); + names.add(ann.values()); + } + else + names.add(ann.value()); + } + + return names; + } + + /** Generates Map reconstruction for all map-flavoured {@code @Marshalled} fields. */ + private void appendMarshalledMapFinish(List<String> body) { + for (VariableElement field : enclosed.values()) { + if (kinds.get(field) != MarshalledKind.MAP) + continue; + + Marshalled ann = field.getAnnotation(Marshalled.class); + + VariableElement keysEl = requireEnclosed(enclosed, ann.keys(), "@Marshalled"); + VariableElement valsEl = requireEnclosed(enclosed, ann.values(), "@Marshalled"); + + String mapField = "msg." + field.getSimpleName(); + String keysField = "msg." + ann.keys(); + String valsField = "msg." + ann.values(); + + List<String> code = keysEl.asType().getKind() == TypeKind.ARRAY + ? mapFinishArrayBlock(field, keysEl, valsEl, mapField, keysField, valsField) + : mapFinishCollectionBlock(keysEl, valsEl, mapField, keysField, valsField); + + appendBlock(body, code); + } + } + + /** Generates indexed-loop Map reconstruction for array-backed map-flavoured {@code @Marshalled} fields. */ + private List<String> mapFinishArrayBlock(VariableElement field, VariableElement keysEl, VariableElement valsEl, String mapField, + String keysField, String valsField) { + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null) {", keysField)); + + indent++; + + if (!field.getModifiers().contains(Modifier.FINAL)) { + code.add(indentedLine("%s = U.newHashMap(%s.length);", mapField, keysField)); + code.add(EMPTY); + } + + code.add(indentedLine("for (int i = 0; i < %s.length; i++) {", keysField)); + + indent++; + + code.addAll(mapPutBlock( + ((ArrayType)keysEl.asType()).getComponentType(), + ((ArrayType)valsEl.asType()).getComponentType(), + arrayComponentName(keysEl) + " k = " + keysField + "[i];", + arrayComponentName(valsEl) + " v = " + valsField + "[i];", + mapField)); + + indent--; + + code.add(indentedLine("}")); + code.add(EMPTY); + code.add(indentedLine("%s = null;", keysField)); + code.add(indentedLine("%s = null;", valsField)); + + indent--; + + code.add(indentedLine("}")); + + return code; + } + + /** Generates iterator-based Map reconstruction for collection-backed map-flavoured {@code @Marshalled} fields. */ + private List<String> mapFinishCollectionBlock(VariableElement keysEl, VariableElement valsEl, String mapField, + String keysField, String valsField) { + TypeMirror keyCompType = ((DeclaredType)keysEl.asType()).getTypeArguments().get(0); + TypeMirror valCompType = ((DeclaredType)valsEl.asType()).getTypeArguments().get(0); + + Element keyElem = element(keyCompType); + Element valElem = element(valCompType); + + String keyCompName = keyElem.getSimpleName().toString(); + String valCompName = valElem.getSimpleName().toString(); + + imports.add(((QualifiedNameable)keyElem).getQualifiedName().toString()); + imports.add(((QualifiedNameable)valElem).getQualifiedName().toString()); + imports.add("java.util.Iterator"); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null) {", keysField)); + + indent++; + + code.add(indentedLine("%s = U.newHashMap(%s.size());", mapField, keysField)); + code.add(EMPTY); + code.add(indentedLine("Iterator<%s> keyIter = %s.iterator();", keyCompName, keysField)); + code.add(indentedLine("Iterator<%s> valIter = %s.iterator();", valCompName, valsField)); + code.add(EMPTY); + code.add(indentedLine("while (keyIter.hasNext()) {")); + + indent++; + + code.addAll(mapPutBlock(keyCompType, valCompType, + keyCompName + " k = keyIter.next();", + valCompName + " v = valIter.next();", + mapField)); + + indent--; + + code.add(indentedLine("}")); + code.add(EMPTY); + code.add(indentedLine("%s = null;", keysField)); + code.add(indentedLine("%s = null;", valsField)); + + indent--; + + code.add(indentedLine("}")); + + return code; + } + + /** + * Generates the reconstruction-loop body shared by both map layouts: k/v declarations, + * element unmarshal and {@code map.put}. + */ + private List<String> mapPutBlock(TypeMirror keyCompType, TypeMirror valCompType, String kDecl, String vDecl, String mapField) { + List<String> code = new ArrayList<>(); + + code.add(indentedLine("%s", kDecl)); + code.add(indentedLine("%s", vDecl)); + + List<String> keyUnmarshal = codeFor(keyCompType, "k", MarshalMode.UNMARSHAL); + List<String> valUnmarshal = codeFor(valCompType, "v", MarshalMode.UNMARSHAL); + + if (!keyUnmarshal.isEmpty()) { + code.add(EMPTY); + code.addAll(keyUnmarshal); + } + + if (!valUnmarshal.isEmpty()) { + code.add(EMPTY); + code.addAll(valUnmarshal); + } + + code.add(EMPTY); + code.add(indentedLine("%s.put(k, v);", mapField)); + + return code; + } + + /** Generates key/value array population from the map's entry set. */ + private List<String> arrayMapBody(Marshalled ann, String mapField, String keysField, VariableElement keysEl, String valuesField) { + String compName = arrayComponentName(keysEl); + String valCompName = arrayComponentName(requireEnclosed(enclosed, ann.values(), "@Marshalled")); + + List<String> inner = new ArrayList<>(); + + imports.add("java.util.Map"); + + inner.add(indentedLine("%s = new %s[%s.size()];", keysField, compName, mapField)); + inner.add(indentedLine("%s = new %s[%s.length];", valuesField, valCompName, keysField)); + inner.add(indentedLine("int i = 0;")); + inner.add(indentedLine("for (Map.Entry<?, ?> e : %s.entrySet()) {", mapField)); + + indent++; + + inner.add(indentedLine("%s[i] = (%s)e.getKey();", keysField, compName)); + inner.add(indentedLine("%s[i] = (%s)e.getValue();", valuesField, valCompName)); + inner.add(indentedLine("i++;")); + + indent--; + + inner.add(indentedLine("}")); + + return inner; + } + + /** Generates key/value assignments backed by the map's own {@code keySet()} and {@code values()} views. */ + private List<String> viewBasedMapBody(String keysField, String mapField, String valuesField) { + List<String> inner = new ArrayList<>(); + + inner.add(indentedLine("%s = %s.keySet();", keysField, mapField)); + inner.add(indentedLine("%s = %s.values();", valuesField, mapField)); + + return inner; + } + + /** Marshals each field and appends non-empty results to {@code body}. */ + private void appendFields(List<String> body, List<VariableElement> fields, MarshalMode mode) { + appendFields(body, fields, mode, Set.of()); + } + + /** Marshals each field, skipping names in {@code skip}, and appends non-empty results to {@code body}. */ + private void appendFields(List<String> body, List<VariableElement> fields, MarshalMode mode, Set<String> skip) { + for (VariableElement field : fields) { + if (skip.contains(field.getSimpleName().toString())) + continue; + + List<String> result = codeFor(field.asType(), fieldAccessor(field), mode); + + if (!result.isEmpty()) + appendBlock(body, result); + } + } + + /** Returns generated marshal/unmarshal code lines for field of type {@code t}, or empty if none needed. */ + private List<String> codeFor(TypeMirror t, String accessor, MarshalMode mode) { + if (t.getKind() == TypeKind.ARRAY) { + TypeMirror comp = ((ArrayType)t).getComponentType(); + + return comp.getKind() == TypeKind.DECLARED ? marshallArray(comp, accessor, mode) : List.of(); + } + + if (t.getKind() == TypeKind.DECLARED || t.getKind() == TypeKind.TYPEVAR) { + if (isMessage(t)) + return isNonMarshallable(t) ? List.of() : marshallMessage(accessor, mode); + if (isCacheObject(t)) + return marshallCacheObject(accessor, mode); + if (isMap(t)) + return marshallMap((DeclaredType)t, accessor, mode); + if (isCollection(t)) + return marshallCollection((DeclaredType)t, accessor, mode); + } + + return List.of(); + } + + /** + * Generates a null-guarded {@code MessageMarshalling.marshal/unmarshal} call. Loop-nested calls go through the + * overloads taking the pre-resolved {@code msgFactory} local (see {@link #prependMsgFactoryResolution}), so the + * factory is not re-resolved from the context on every element. + */ + private List<String> marshallMessage(String accessor, MarshalMode mode) { + imports.add("org.apache.ignite.internal.managers.communication.MessageMarshalling"); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null)", accessor)); + + indent++; + + if (loopDepth > 0) { + usesMsgFactory = true; + + code.add(mode == MarshalMode.MARSHAL + ? indentedLine("MessageMarshalling.marshal(msgFactory, %s, kctx, ctx);", accessor) + : indentedLine("MessageMarshalling.unmarshal(msgFactory, %s, kctx, ctx, clsLdr);", accessor)); + } + else { + code.add(mode == MarshalMode.MARSHAL + ? indentedLine("MessageMarshalling.marshal(%s, kctx, ctx);", accessor) + : indentedLine("MessageMarshalling.unmarshal(%s, kctx, ctx, clsLdr);", accessor)); + } + + indent--; + + return code; + } + + /** Generates a null-and-ctx-guarded {@code marshal/unmarshal} call on a {@code CacheObject} (marshal or cache-aware unmarshal only). */ + private List<String> marshallCacheObject(String accessor, MarshalMode mode) { + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null && ctx != null)", accessor)); + + indent++; + + code.add(mode == MarshalMode.MARSHAL + ? indentedLine("%s.marshal(ctx);", accessor) + : indentedLine("%s.unmarshal(ctx, clsLdr);", accessor)); + + indent--; + + return code; + } + + /** Generates a null-guarded for-each loop over the array's elements. */ + private List<String> marshallArray(TypeMirror comp, String accessor, MarshalMode mode) { + Element elem = ((DeclaredType)comp).asElement(); + + indent++; + + List<String> loopCode = forLoop(elem.getSimpleName().toString(), comp, accessor, mode); + + indent--; + + if (!loopCode.isEmpty()) + imports.add(((QualifiedNameable)elem).getQualifiedName().toString()); + + return wrapNullGuarded(accessor, loopCode); + } + + /** Generates a null-guarded for-each loop over the collection's elements. */ + private List<String> marshallCollection(DeclaredType t, String accessor, MarshalMode mode) { + TypeMirror arg = t.getTypeArguments().get(0); + + if (arg.getKind() != TypeKind.DECLARED && arg.getKind() != TypeKind.TYPEVAR) + return List.of(); + + Element elem = element(arg); + + String typeName = elem.getSimpleName().toString(); + + indent++; + + List<String> loopCode = forLoop(typeName, arg, "(Collection<? extends " + typeName + ">)" + accessor, mode); + + indent--; + + if (!loopCode.isEmpty()) { + imports.add(((QualifiedNameable)elem).getQualifiedName().toString()); + imports.add("java.util.Collection"); + } + + return wrapNullGuarded(accessor, loopCode); + } + + /** Iterates {@code keySet()} then {@code values()}, wrapping both loops in a null-guard. */ + private List<String> marshallMap(DeclaredType t, String accessor, MarshalMode mode) { + List<? extends TypeMirror> args = t.getTypeArguments(); + + indent++; + + List<String> combined = new ArrayList<>(); + + for (int i = 0; i < 2; i++) { + TypeMirror elemType = args.get(i); + + if (elemType.getKind() != TypeKind.DECLARED && elemType.getKind() != TypeKind.TYPEVAR) + continue; + + Element elem = element(elemType); + + String typeName = elem.getSimpleName().toString(); + String collection = i == 0 ? "keySet" : "values"; + String iterable = "((Collection<? extends " + typeName + ">)" + accessor + "." + collection + "())"; + + List<String> loopCode = forLoop(typeName, elemType, iterable, mode); + + if (loopCode.isEmpty()) + continue; + + imports.add(((QualifiedNameable)elem).getQualifiedName().toString()); + imports.add("java.util.Collection"); + + combined.addAll(loopCode); + } + + indent--; + + return wrapNullGuarded(accessor, combined); + } + + /** Returns empty if {@code elemType} requires no marshalling; otherwise returns a for-each loop over {@code iterable}. */ + private List<String> forLoop(String typeName, TypeMirror elemType, String iterable, MarshalMode mode) { + String el = loopDepth == 0 ? "e" : "e" + loopDepth; + + loopDepth++; + indent++; + + List<String> inner = codeFor(elemType, el, mode); + + indent--; + loopDepth--; + + if (inner.isEmpty()) + return List.of(); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("for (%s %s : %s) {", typeName, el, iterable)); + + code.addAll(inner); + + code.add(indentedLine("}")); + + return code; + } + + /** Prefixes {@code body} with the {@code msgFactory} resolution line when a loop-nested facade call was emitted. */ + private void prependMsgFactoryResolution(List<String> body) { + if (!usesMsgFactory) + return; + + imports.add("org.apache.ignite.internal.managers.communication.IgniteMessageFactory"); + + body.add(0, EMPTY); + body.add(0, indentedLine("IgniteMessageFactory msgFactory = (IgniteMessageFactory)kctx.messageFactory();")); + } + + /** Returns empty if {@code inner} is empty; otherwise wraps {@code inner} in a null-guard on {@code nullGuard}. */ + private List<String> wrapNullGuarded(String nullGuard, List<String> inner) { + if (inner.isEmpty()) + return List.of(); + + List<String> code = new ArrayList<>(); + + code.add(indentedLine("if (%s != null) {", nullGuard)); + + code.addAll(inner); + + code.add(indentedLine("}")); + + return code; + } + + /** + * Returns the {@code CacheObjectContext ctx} resolution line for the current message type. Cache messages resolve + * via the cache, group messages via the cache group — the group's context outlives the stop of individual caches, + * so cache objects still unmarshal while a cache (group) is being destroyed. + */ + private String ctxResolutionLine() { + if (isCacheIdAwareMessage(type)) + return indentedLine("CacheObjectContext ctx = cacheObjCtx != null ? cacheObjCtx : " + + "kctx.cache().context().cacheObjectContext(msg.cacheId());"); + else if (isCacheGroupIdMessage(type)) + return indentedLine("CacheObjectContext ctx = cacheObjCtx != null ? cacheObjCtx : " + + "kctx.cache().cacheGroup(msg.groupId()) == null ? null : " + + "kctx.cache().cacheGroup(msg.groupId()).cacheObjectContext();"); + else + return indentedLine("CacheObjectContext ctx = cacheObjCtx;"); + } + + /** Returns {@code true} if any field requires {@code ctx} in generated marshal/unmarshal code. */ + private boolean needsCtx(List<VariableElement> fields) { + return fields.stream().anyMatch(f -> needsCtxType(f.asType())); + } + + /** + * Returns whether the {@code @Order} fields of {@code msgType} need a cache object context to unmarshal. Such a + * message must not be a {@code @NioField}: its {@code unmarshalNio} runs on the NIO thread, which has no context. + * A type with no fields to inspect (e.g. a type variable) is conservatively assumed to need the context. + */ + private boolean nestedNeedsCtx(TypeMirror type) { + Element el = env.getTypeUtils().asElement(type); + + if (!(el instanceof TypeElement)) + return true; + + return SystemViewRowAttributeWalkerProcessor.superclasses(env, (TypeElement)el) + .flatMap(c -> ElementFilter.fieldsIn(c.getEnclosedElements()).stream()) + .filter(f -> f.getAnnotation(Order.class) != null) + .anyMatch(f -> needsCtxType(f.asType())); + } + + /** Returns {@code true} if type {@code t} (or its element/key/value types) requires {@code ctx}. */ + private boolean needsCtxType(TypeMirror t) { + if (t.getKind() == TypeKind.ARRAY) + return needsCtxType(((ArrayType)t).getComponentType()); + + if (t.getKind() == TypeKind.DECLARED || t.getKind() == TypeKind.TYPEVAR) { + if (isMessage(t)) + return !isNonMarshallable(t); + + if (isCacheObject(t)) + return true; + + if (isMap(t)) { + List<? extends TypeMirror> args = ((DeclaredType)t).getTypeArguments(); + return needsCtxType(args.get(0)) || needsCtxType(args.get(1)); + } + + if (isCollection(t)) { + List<? extends TypeMirror> args = ((DeclaredType)t).getTypeArguments(); + return needsCtxType(args.get(0)); + } + } + + return false; + } + + /** */ + private boolean isMessage(TypeMirror type) { + return assignableFrom(type, msgType); + } + + /** */ + private boolean isCacheObject(TypeMirror type) { + return assignableFrom(type, cacheObjType); + } + + /** Returns {@code true} if {@code type} (erased) is assignable to {@code java.util.Map}. */ + private boolean isMap(TypeMirror type) { + return assignableFrom(erasedType(type), mapType); + } + + /** Returns {@code true} if {@code type} (erased) is assignable to {@code java.util.Collection}. */ + private boolean isCollection(TypeMirror type) { + return assignableFrom(erasedType(type), colType); + } + + /** */ + private boolean isNonMarshallableMessage(TypeElement te) { + return isNonMarshallable(te.asType()); + } + + /** Recursion skip for such fields is subtype-safe: subclasses inherit the {@code NonMarshallableMessage} marker. */ + private boolean isNonMarshallable(TypeMirror t) { Review Comment: Usen in one place. Might be just ` isNonMarshallable(te.asType())` -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
