private void generateClassFromStruct()

in generator/src/main/java/org/apache/kafka/message/MessageDataGenerator.java [686:800]
114 lines of code
7 McCabe index (conditional complexity)

    private void generateClassFromStruct(String className, StructSpec struct,
                                         Versions parentVersions) {
        headerGenerator.addImport(MessageGenerator.STRUCT_CLASS);
        buffer.printf("@SuppressWarnings(\"unchecked\")%n");
        buffer.printf("@Override%n");
        buffer.printf("public void fromStruct(Struct struct, short _version) {%n");
        buffer.incrementIndent();
        VersionConditional.forVersions(parentVersions, struct.versions()).
            allowMembershipCheckAlwaysFalse(false).
            ifNotMember(__ -> {
                headerGenerator.addImport(MessageGenerator.UNSUPPORTED_VERSION_EXCEPTION_CLASS);
                buffer.printf("throw new UnsupportedVersionException(\"Can't read " +
                    "version \" + _version + \" of %s\");%n", className);
            }).
            generate(buffer);
        Versions curVersions = parentVersions.intersect(struct.versions());
        if (!messageFlexibleVersions.intersect(struct.versions()).empty()) {
            buffer.printf("NavigableMap<Integer, Object> _taggedFields = null;%n");
        }
        buffer.printf("this._unknownTaggedFields = null;%n");
        VersionConditional.forVersions(messageFlexibleVersions, struct.versions()).
            ifMember(__ -> {
                headerGenerator.addImport(MessageGenerator.NAVIGABLE_MAP_CLASS);
                buffer.printf("_taggedFields = (NavigableMap<Integer, Object>) " +
                    "struct.get(\"%s\");%n", TAGGED_FIELDS_SECTION_NAME);
            }).
            generate(buffer);
        for (FieldSpec field : struct.fields()) {
            VersionConditional.forVersions(field.versions(), curVersions).
                alwaysEmitBlockScope(field.type().isArray()).
                ifNotMember(__ -> {
                    buffer.printf("this.%s = %s;%n", field.camelCaseName(),
                        field.fieldDefault(headerGenerator, structRegistry));
                }).
                ifMember(presentVersions -> {
                    VersionConditional.forVersions(field.taggedVersions(), presentVersions).
                        ifNotMember(presentAndUntaggedVersions -> {
                            if (field.type().isArray()) {
                                buffer.printf("Object[] _nestedObjects = struct.getArray(\"%s\");%n",
                                    field.snakeCaseName());
                                generateArrayFromStruct(field, presentAndUntaggedVersions);
                            } else {
                                buffer.printf("this.%s = %s;%n",
                                    field.camelCaseName(),
                                    readFieldFromStruct(field.type(), field.snakeCaseName(), field.zeroCopy()));
                            }
                        }).
                        ifMember(presentAndTaggedVersions -> {
                            buffer.printf("if (_taggedFields.containsKey(%d)) {%n", field.tag().get());
                            buffer.incrementIndent();
                            if (field.type().isArray()) {
                                buffer.printf("Object[] _nestedObjects = " +
                                    "(Object[]) _taggedFields.remove(%d);%n", field.tag().get());
                                generateArrayFromStruct(field, presentAndTaggedVersions);
                            } else if (field.type().isBytes()) {
                                headerGenerator.addImport(MessageGenerator.BYTE_BUFFER_CLASS);
                                buffer.printf("ByteBuffer _byteBuffer = (ByteBuffer) _taggedFields.remove(%d);%n",
                                    field.tag().get());

                                IsNullConditional.forName("_byteBuffer").
                                    nullableVersions(field.nullableVersions()).
                                    possibleVersions(field.versions()).
                                    ifNull(() -> {
                                        buffer.printf("this.%s = null;%n", field.camelCaseName());
                                    }).
                                    ifShouldNotBeNull(() -> {
                                        headerGenerator.addImport(MessageGenerator.MESSAGE_UTIL_CLASS);
                                        buffer.printf("this.%s = MessageUtil.byteBufferToArray(_byteBuffer);%n",
                                            field.camelCaseName());
                                    }).
                                    generate(buffer);
                            } else if (field.type().isStruct()) {
                                buffer.printf("this.%s = new %s((Struct) _taggedFields.remove(%d), _version);%n",
                                    field.camelCaseName(),
                                    field.type().getBoxedJavaType(headerGenerator),
                                    field.tag().get());
                            } else {
                                buffer.printf("this.%s = (%s) _taggedFields.remove(%d);%n",
                                    field.camelCaseName(),
                                    field.type().getBoxedJavaType(headerGenerator),
                                    field.tag().get());
                            }
                            buffer.decrementIndent();
                            buffer.printf("} else {%n");
                            buffer.incrementIndent();
                            buffer.printf("this.%s = %s;%n", field.camelCaseName(),
                                field.fieldDefault(headerGenerator, structRegistry));
                            buffer.decrementIndent();
                            buffer.printf("}%n");
                        }).
                        generate(buffer);
                }).
                generate(buffer);
        }
        VersionConditional.forVersions(messageFlexibleVersions, struct.versions()).
            ifMember(__ -> {
                headerGenerator.addImport(MessageGenerator.NAVIGABLE_MAP_CLASS);
                buffer.printf("if (!_taggedFields.isEmpty()) {%n");
                buffer.incrementIndent();
                headerGenerator.addImport(MessageGenerator.ARRAYLIST_CLASS);
                buffer.printf("this._unknownTaggedFields = new ArrayList<>(_taggedFields.size());%n");
                headerGenerator.addStaticImport(MessageGenerator.MAP_ENTRY_CLASS);
                buffer.printf("for (Entry<Integer, Object> entry : _taggedFields.entrySet()) {%n");
                buffer.incrementIndent();
                headerGenerator.addImport(MessageGenerator.RAW_TAGGED_FIELD_CLASS);
                buffer.printf("this._unknownTaggedFields.add((RawTaggedField) entry.getValue());%n");
                buffer.decrementIndent();
                buffer.printf("}%n");
                buffer.decrementIndent();
                buffer.printf("}%n");
            }).
            generate(buffer);
        buffer.decrementIndent();
        buffer.printf("}%n");
    }