/*
 * 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.kafka.message;

import java.io.Writer;
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * Generates Kafka MessageData classes.
 */
public final class MessageDataGenerator {
    private final HeaderGenerator headerGenerator;
    private final SchemaGenerator schemaGenerator;
    private final CodeBuffer buffer;

    MessageDataGenerator() {
        this.headerGenerator = new HeaderGenerator();
        this.schemaGenerator = new SchemaGenerator(headerGenerator);
        this.buffer = new CodeBuffer();
    }

    void generate(MessageSpec message) throws Exception {
        if (message.struct().versions().contains(Short.MAX_VALUE)) {
            throw new RuntimeException("Message " + message.name() + " does " +
                "not specify a maximum version.");
        }
        schemaGenerator.generateSchemas(message);
        generateClass(Optional.of(message),
            message.name() + "Data",
            message.struct(),
            message.struct().versions());
        headerGenerator.generate();
    }

    void write(Writer writer) throws Exception {
        headerGenerator.buffer().write(writer);
        buffer.write(writer);
    }

    private void generateClass(Optional<MessageSpec> topLevelMessageSpec,
                               String className,
                               StructSpec struct,
                               Versions parentVersions) throws Exception {
        buffer.printf("%n");
        boolean isTopLevel = topLevelMessageSpec.isPresent();
        boolean isSetElement = struct.hasKeys(); // Check if the class is inside a set.
        if (isTopLevel && isSetElement) {
            throw new RuntimeException("Cannot set mapKey on top level fields.");
        }
        generateClassHeader(className, isTopLevel, isSetElement);
        buffer.incrementIndent();
        generateFieldDeclarations(struct, isSetElement);
        buffer.printf("%n");
        schemaGenerator.writeSchema(className, buffer);
        generateClassConstructors(className, struct);
        buffer.printf("%n");
        if (isTopLevel) {
            generateShortAccessor("apiKey", topLevelMessageSpec.get().apiKey().orElse((short) -1));
        }
        buffer.printf("%n");
        generateShortAccessor("lowestSupportedVersion", parentVersions.lowest());
        buffer.printf("%n");
        generateShortAccessor("highestSupportedVersion", parentVersions.highest());
        buffer.printf("%n");
        generateClassReader(className, struct, parentVersions);
        buffer.printf("%n");
        generateClassWriter(className, struct, parentVersions);
        buffer.printf("%n");
        generateClassFromStruct(className, struct, parentVersions);
        buffer.printf("%n");
        generateClassToStruct(className, struct, parentVersions);
        buffer.printf("%n");
        generateClassSize(className, struct, parentVersions);
        buffer.printf("%n");
        generateClassEquals(className, struct, isSetElement);
        buffer.printf("%n");
        generateClassHashCode(struct, isSetElement);
        buffer.printf("%n");
        generateClassToString(className, struct);
        generateFieldAccessors(struct, isSetElement);
        generateFieldMutators(struct, className, isSetElement);

        if (!isTopLevel) {
            buffer.decrementIndent();
            buffer.printf("}%n");
        }
        generateSubclasses(className, struct, parentVersions, isSetElement);
        if (isTopLevel) {
            buffer.decrementIndent();
            buffer.printf("}%n");
        }
    }

    private void generateClassHeader(String className, boolean isTopLevel,
                                     boolean isSetElement) {
        Set<String> implementedInterfaces = new HashSet<>();
        if (isTopLevel) {
            implementedInterfaces.add("ApiMessage");
            headerGenerator.addImport(MessageGenerator.API_MESSAGE_CLASS);
        } else {
            implementedInterfaces.add("Message");
            headerGenerator.addImport(MessageGenerator.MESSAGE_CLASS);
        }
        if (isSetElement) {
            headerGenerator.addImport(MessageGenerator.IMPLICIT_LINKED_HASH_MULTI_COLLECTION_CLASS);
            implementedInterfaces.add("ImplicitLinkedHashMultiCollection.Element");
        }
        Set<String> classModifiers = new HashSet<>();
        classModifiers.add("public");
        if (!isTopLevel) {
            classModifiers.add("static");
        }
        buffer.printf("%s class %s implements %s {%n",
            String.join(" ", classModifiers),
            className,
            String.join(", ", implementedInterfaces));
    }

    private void generateSubclasses(String className, StructSpec struct,
            Versions parentVersions, boolean isSetElement) throws Exception {
        for (FieldSpec field : struct.fields()) {
            if (field.type().isStructArray()) {
                FieldType.ArrayType arrayType = (FieldType.ArrayType) field.type();
                generateClass(Optional.empty(),
                    arrayType.elementType().toString(),
                    field.toStruct(),
                    parentVersions.intersect(struct.versions()));
            }
        }
        if (isSetElement) {
            generateHashSet(className, struct);
        }
    }

    private void generateHashSet(String className, StructSpec struct) {
        buffer.printf("%n");
        headerGenerator.addImport(MessageGenerator.IMPLICIT_LINKED_HASH_MULTI_COLLECTION_CLASS);
        buffer.printf("public static class %s extends ImplicitLinkedHashMultiCollection<%s> {%n",
            collectionType(className), className);
        buffer.incrementIndent();
        generateHashSetZeroArgConstructor(className);
        generateHashSetSizeArgConstructor(className);
        generateHashSetIteratorConstructor(className);
        generateHashSetFindMethod(className, struct);
        generateHashSetFindAllMethod(className, struct);
        buffer.decrementIndent();
        buffer.printf("}%n");
    }

    private void generateHashSetZeroArgConstructor(String className) {
        buffer.printf("public %s() {%n", collectionType(className));
        buffer.incrementIndent();
        buffer.printf("super();%n");
        buffer.decrementIndent();
        buffer.printf("}%n");
        buffer.printf("%n");
    }

    private void generateHashSetSizeArgConstructor(String className) {
        buffer.printf("public %s(int expectedNumElements) {%n", collectionType(className));
        buffer.incrementIndent();
        buffer.printf("super(expectedNumElements);%n");
        buffer.decrementIndent();
        buffer.printf("}%n");
        buffer.printf("%n");
    }

    private void generateHashSetIteratorConstructor(String className) {
        headerGenerator.addImport(MessageGenerator.ITERATOR_CLASS);
        buffer.printf("public %s(Iterator<%s> iterator) {%n", collectionType(className), className);
        buffer.incrementIndent();
        buffer.printf("super(iterator);%n");
        buffer.decrementIndent();
        buffer.printf("}%n");
        buffer.printf("%n");
    }

    private void generateHashSetFindMethod(String className, StructSpec struct) {
        headerGenerator.addImport(MessageGenerator.LIST_CLASS);
        buffer.printf("public %s find(%s) {%n", className,
            commaSeparatedHashSetFieldAndTypes(struct));
        buffer.incrementIndent();
        generateKeyElement(className, struct);
        headerGenerator.addImport(MessageGenerator.IMPLICIT_LINKED_HASH_MULTI_COLLECTION_CLASS);
        buffer.printf("return find(key);%n");
        buffer.decrementIndent();
        buffer.printf("}%n");
        buffer.printf("%n");
    }

    private void generateHashSetFindAllMethod(String className, StructSpec struct) {
        headerGenerator.addImport(MessageGenerator.LIST_CLASS);
        buffer.printf("public List<%s> findAll(%s) {%n", className,
            commaSeparatedHashSetFieldAndTypes(struct));
        buffer.incrementIndent();
        generateKeyElement(className, struct);
        headerGenerator.addImport(MessageGenerator.IMPLICIT_LINKED_HASH_MULTI_COLLECTION_CLASS);
        buffer.printf("return findAll(key);%n");
        buffer.decrementIndent();
        buffer.printf("}%n");
        buffer.printf("%n");
    }

    private void generateKeyElement(String className, StructSpec struct) {
        buffer.printf("%s key = new %s();%n", className, className);
        for (FieldSpec field : struct.fields()) {
            if (field.mapKey()) {
                buffer.printf("key.set%s(%s);%n",
                    field.capitalizedCamelCaseName(),
                    field.camelCaseName());
            }
        }
    }

    private String commaSeparatedHashSetFieldAndTypes(StructSpec struct) {
        return struct.fields().stream().
            filter(f -> f.mapKey()).
            map(f -> String.format("%s %s", fieldConcreteJavaType(f), f.camelCaseName())).
            collect(Collectors.joining(", "));
    }

    private void generateFieldDeclarations(StructSpec struct, boolean isSetElement) {
        for (FieldSpec field : struct.fields()) {
            generateFieldDeclaration(field);
        }
        if (isSetElement) {
            buffer.printf("private int next;%n");
            buffer.printf("private int prev;%n");
        }
    }

    private void generateFieldDeclaration(FieldSpec field) {
        buffer.printf("private %s %s;%n",
            fieldAbstractJavaType(field), field.camelCaseName());
    }

    private void generateFieldAccessors(StructSpec struct, boolean isSetElement) {
        for (FieldSpec field : struct.fields()) {
            generateFieldAccessor(field);
        }
        if (isSetElement) {
            buffer.printf("%n");
            buffer.printf("@Override%n");
            generateAccessor("int", "next", "next");

            buffer.printf("%n");
            buffer.printf("@Override%n");
            generateAccessor("int", "prev", "prev");
        }
    }

    private void generateFieldMutators(StructSpec struct, String className,
                                       boolean isSetElement) {
        for (FieldSpec field : struct.fields()) {
            generateFieldMutator(className, field);
        }
        if (isSetElement) {
            buffer.printf("%n");
            buffer.printf("@Override%n");
            generateSetter("int", "setNext", "next");

            buffer.printf("%n");
            buffer.printf("@Override%n");
            generateSetter("int", "setPrev", "prev");
        }
    }

    private static String collectionType(String baseType) {
        return baseType + "Collection";
    }

    private String fieldAbstractJavaType(FieldSpec field) {
        if (field.type() instanceof FieldType.BoolFieldType) {
            return "boolean";
        } else if (field.type() instanceof FieldType.Int8FieldType) {
            return "byte";
        } else if (field.type() instanceof FieldType.Int16FieldType) {
            return "short";
        } else if (field.type() instanceof FieldType.Int32FieldType) {
            return "int";
        } else if (field.type() instanceof FieldType.Int64FieldType) {
            return "long";
        } else if (field.type().isString()) {
            return "String";
        } else if (field.type().isBytes()) {
            return "byte[]";
        } else if (field.type().isStruct()) {
            return MessageGenerator.capitalizeFirst(field.typeString());
        } else if (field.type().isArray()) {
            FieldType.ArrayType arrayType = (FieldType.ArrayType) field.type();
            if (field.toStruct().hasKeys()) {
                headerGenerator.addImport(MessageGenerator.IMPLICIT_LINKED_HASH_MULTI_COLLECTION_CLASS);
                return collectionType(arrayType.elementType().toString());
            } else {
                headerGenerator.addImport(MessageGenerator.LIST_CLASS);
                return "List<" + getBoxedJavaType(arrayType.elementType()) + ">";
            }
        } else {
            throw new RuntimeException("Unknown field type " + field.type());
        }
    }

    private String fieldConcreteJavaType(FieldSpec field) {
        if (field.type().isArray()) {
            FieldType.ArrayType arrayType = (FieldType.ArrayType) field.type();
            if (field.toStruct().hasKeys()) {
                headerGenerator.addImport(MessageGenerator.IMPLICIT_LINKED_HASH_MULTI_COLLECTION_CLASS);
                return collectionType(arrayType.elementType().toString());
            } else {
                headerGenerator.addImport(MessageGenerator.ARRAYLIST_CLASS);
                return "ArrayList<" + getBoxedJavaType(arrayType.elementType()) + ">";
            }
        } else {
            return fieldAbstractJavaType(field);
        }
    }

    private void generateClassConstructors(String className, StructSpec struct) {
        headerGenerator.addImport(MessageGenerator.READABLE_CLASS);
        buffer.printf("public %s(Readable readable, short version) {%n", className);
        buffer.incrementIndent();
        initializeArrayDefaults(struct);
        buffer.printf("read(readable, version);%n");
        buffer.decrementIndent();
        buffer.printf("}%n");
        buffer.printf("%n");
        headerGenerator.addImport(MessageGenerator.STRUCT_CLASS);
        buffer.printf("public %s(Struct struct, short version) {%n", className);
        buffer.incrementIndent();
        initializeArrayDefaults(struct);
        buffer.printf("fromStruct(struct, version);%n");
        buffer.decrementIndent();
        buffer.printf("}%n");
        buffer.printf("%n");
        buffer.printf("public %s() {%n", className);
        buffer.incrementIndent();
        for (FieldSpec field : struct.fields()) {
            buffer.printf("this.%s = %s;%n",
                field.camelCaseName(), fieldDefault(field));
        }
        buffer.decrementIndent();
        buffer.printf("}%n");
    }

    private void initializeArrayDefaults(StructSpec struct) {
        for (FieldSpec field : struct.fields()) {
            if (field.type().isArray()) {
                buffer.printf("this.%s = %s;%n",
                    field.camelCaseName(), fieldDefault(field));
            }
        }
    }

    private void generateShortAccessor(String name, short val) {
        buffer.printf("@Override%n");
        buffer.printf("public short %s() {%n", name);
        buffer.incrementIndent();
        buffer.printf("return %d;%n", val);
        buffer.decrementIndent();
        buffer.printf("}%n");
    }

    private void generateClassReader(String className, StructSpec struct,
                                     Versions parentVersions) {
        headerGenerator.addImport(MessageGenerator.READABLE_CLASS);
        buffer.printf("@Override%n");
        buffer.printf("public void read(Readable readable, short version) {%n");
        buffer.incrementIndent();
        if (generateInverseVersionCheck(parentVersions, struct.versions())) {
            buffer.incrementIndent();
            headerGenerator.addImport(MessageGenerator.UNSUPPORTED_VERSION_EXCEPTION_CLASS);
            buffer.printf("throw new UnsupportedVersionException(\"Can't read " +
                "version \" + version + \" of %s\");%n", className);
            buffer.decrementIndent();
            buffer.printf("}%n");
        }
        Versions curVersions = parentVersions.intersect(struct.versions());
        if (curVersions.empty()) {
            throw new RuntimeException("Version ranges " + parentVersions +
                " and " + struct.versions() + " have no versions in common.");
        }
        for (FieldSpec field : struct.fields()) {
            generateFieldReader(field, curVersions);
        }
        buffer.decrementIndent();
        buffer.printf("}%n");
    }

    private void generateFieldReader(FieldSpec field, Versions curVersions) {
        if (field.type().isArray()) {
            boolean maybeAbsent =
                generateVersionCheck(curVersions, field.versions());
            if (!maybeAbsent) {
                buffer.printf("{%n");
                buffer.incrementIndent();
            }
            boolean hasKeys = field.toStruct().hasKeys();
            buffer.printf("int arrayLength = readable.readInt();%n");
            buffer.printf("if (arrayLength < 0) {%n");
            buffer.incrementIndent();
            buffer.printf("this.%s = null;%n",
                field.camelCaseName());
            buffer.decrementIndent();
            buffer.printf("} else {%n");
            buffer.incrementIndent();
            buffer.printf("this.%s.clear(%s);%n",
                field.camelCaseName(),
                hasKeys ? "arrayLength" : "");
            buffer.printf("for (int i = 0; i < arrayLength; i++) {%n");
            buffer.incrementIndent();
            FieldType.ArrayType arrayType = (FieldType.ArrayType) field.type();
            buffer.printf("this.%s.add(%s);%n",
                field.camelCaseName(), readFieldFromReadable(arrayType.elementType()));
            buffer.decrementIndent();
            buffer.printf("}%n");
            buffer.decrementIndent();
            buffer.printf("}%n");
            if (maybeAbsent) {
                generateSetDefault(field);
            } else {
                buffer.decrementIndent();
                buffer.printf("}%n");
            }
        } else {
            boolean maybeAbsent =
                generateVersionCheck(curVersions, field.versions());
            buffer.printf("this.%s = %s;%n",
                field.camelCaseName(),
                readFieldFromReadable(field.type()));
            if (maybeAbsent) {
                generateSetDefault(field);
            }
        }
    }

    private String readFieldFromReadable(FieldType type) {
        if (type instanceof FieldType.BoolFieldType) {
            return "readable.readByte() != 0";
        } else if (type instanceof FieldType.Int8FieldType) {
            return "readable.readByte()";
        } else if (type instanceof FieldType.Int16FieldType) {
            return "readable.readShort()";
        } else if (type instanceof FieldType.Int32FieldType) {
            return "readable.readInt()";
        } else if (type instanceof FieldType.Int64FieldType) {
            return "readable.readLong()";
        } else if (type.isString()) {
            return "readable.readNullableString()";
        } else if (type.isBytes()) {
            return "readable.readNullableBytes()";
        } else if (type.isStruct()) {
            return String.format("new %s(readable, version)", type.toString());
        } else {
            throw new RuntimeException("Unsupported field type " + type);
        }
    }

    private void generateClassFromStruct(String className, StructSpec struct,
                                         Versions parentVersions) {
        headerGenerator.addImport(MessageGenerator.STRUCT_CLASS);
        buffer.printf("@Override%n");
        buffer.printf("public void fromStruct(Struct struct, short version) {%n");
        buffer.incrementIndent();
        if (generateInverseVersionCheck(parentVersions, struct.versions())) {
            buffer.incrementIndent();
            headerGenerator.addImport(MessageGenerator.UNSUPPORTED_VERSION_EXCEPTION_CLASS);
            buffer.printf("throw new UnsupportedVersionException(\"Can't read " +
                "version \" + version + \" of %s\");%n", className);
            buffer.decrementIndent();
            buffer.printf("}%n");
        }
        Versions curVersions = parentVersions.intersect(struct.versions());
        if (curVersions.empty()) {
            throw new RuntimeException("Version ranges " + parentVersions +
                " and " + struct.versions() + " have no versions in common.");
        }
        for (FieldSpec field : struct.fields()) {
            generateFieldFromStruct(field, curVersions);
        }
        buffer.decrementIndent();
        buffer.printf("}%n");
    }

    private void generateFieldFromStruct(FieldSpec field, Versions curVersions) {
        if (field.type().isArray()) {
            boolean maybeAbsent =
                generateVersionCheck(curVersions, field.versions());
            if (!maybeAbsent) {
                buffer.printf("{%n");
                buffer.incrementIndent();
            }
            headerGenerator.addImport(MessageGenerator.STRUCT_CLASS);
            buffer.printf("Object[] nestedObjects = struct.getArray(\"%s\");%n",
                field.snakeCaseName());
            boolean maybeNull = false;
            if (!curVersions.intersect(field.nullableVersions()).empty()) {
                maybeNull = true;
                buffer.printf("if (nestedObjects == null) {%n", field.camelCaseName());
                buffer.incrementIndent();
                buffer.printf("this.%s = null;%n", field.camelCaseName());
                buffer.decrementIndent();
                buffer.printf("} else {%n");
                buffer.incrementIndent();
            }
            FieldType.ArrayType arrayType = (FieldType.ArrayType) field.type();
            FieldType elementType = arrayType.elementType();
            buffer.printf("this.%s = new %s(nestedObjects.length);%n",
                field.camelCaseName(), fieldConcreteJavaType(field));
            buffer.printf("for (Object nestedObject : nestedObjects) {%n");
            buffer.incrementIndent();
            if (elementType.isStruct()) {
                buffer.printf("this.%s.add(new %s((Struct) nestedObject, version));%n",
                    field.camelCaseName(), elementType.toString());
            } else {
                buffer.printf("this.%s.add((%s) nestedObject);%n",
                    field.camelCaseName(), getBoxedJavaType(elementType));
            }
            buffer.decrementIndent();
            buffer.printf("}%n");
            if (maybeNull) {
                buffer.decrementIndent();
                buffer.printf("}%n");
            }
            if (maybeAbsent) {
                generateSetDefault(field);
            } else {
                buffer.decrementIndent();
                buffer.printf("}%n");
            }
        } else {
            boolean maybeAbsent =
                generateVersionCheck(curVersions, field.versions());
            buffer.printf("this.%s = %s;%n",
                field.camelCaseName(),
                readFieldFromStruct(field.type(), field.snakeCaseName()));
            if (maybeAbsent) {
                generateSetDefault(field);
            }
        }
    }

    private String getBoxedJavaType(FieldType type) {
        if (type instanceof FieldType.BoolFieldType) {
            return "Boolean";
        } else if (type instanceof FieldType.Int8FieldType) {
            return "Byte";
        } else if (type instanceof FieldType.Int16FieldType) {
            return "Short";
        } else if (type instanceof FieldType.Int32FieldType) {
            return "Integer";
        } else if (type instanceof FieldType.Int64FieldType) {
            return "Long";
        } else if (type.isString()) {
            return "String";
        } else if (type.isStruct()) {
            return type.toString();
        } else {
            throw new RuntimeException("Unsupported field type " + type);
        }
    }

    private String readFieldFromStruct(FieldType type, String name) {
        if (type instanceof FieldType.BoolFieldType) {
            return String.format("struct.getBoolean(\"%s\")", name);
        } else if (type instanceof FieldType.Int8FieldType) {
            return String.format("struct.getByte(\"%s\")", name);
        } else if (type instanceof FieldType.Int16FieldType) {
            return String.format("struct.getShort(\"%s\")", name);
        } else if (type instanceof FieldType.Int32FieldType) {
            return String.format("struct.getInt(\"%s\")", name);
        } else if (type instanceof FieldType.Int64FieldType) {
            return String.format("struct.getLong(\"%s\")", name);
        } else if (type.isString()) {
            return String.format("struct.getString(\"%s\")", name);
        } else if (type.isBytes()) {
            return String.format("struct.getByteArray(\"%s\")", name);
        } else if (type.isStruct()) {
            return String.format("new %s(struct, version)", type.toString());
        } else {
            throw new RuntimeException("Unsupported field type " + type);
        }
    }

    private void generateClassWriter(String className, StructSpec struct,
            Versions parentVersions) {
        headerGenerator.addImport(MessageGenerator.WRITABLE_CLASS);
        buffer.printf("@Override%n");
        buffer.printf("public void write(Writable writable, short version) {%n");
        buffer.incrementIndent();
        if (generateInverseVersionCheck(parentVersions, struct.versions())) {
            buffer.incrementIndent();
            headerGenerator.addImport(MessageGenerator.UNSUPPORTED_VERSION_EXCEPTION_CLASS);
            buffer.printf("throw new UnsupportedVersionException(\"Can't write " +
                "version \" + version + \" of %s\");%n", className);
            buffer.decrementIndent();
            buffer.printf("}%n");
        }
        Versions curVersions = parentVersions.intersect(struct.versions());
        if (curVersions.empty()) {
            throw new RuntimeException("Version ranges " + parentVersions +
                " and " + struct.versions() + " have no versions in common.");
        }
        for (FieldSpec field : struct.fields()) {
            generateFieldWriter(field, curVersions);
        }
        buffer.decrementIndent();
        buffer.printf("}%n");
    }

    private String writeFieldToWritable(FieldType type, boolean nullable, String name) {
        if (type instanceof FieldType.BoolFieldType) {
            return String.format("writable.writeByte(%s ? (byte) 1 : (byte) 0)", name);
        } else if (type instanceof FieldType.Int8FieldType) {
            return String.format("writable.writeByte(%s)", name);
        } else if (type instanceof FieldType.Int16FieldType) {
            return String.format("writable.writeShort(%s)", name);
        } else if (type instanceof FieldType.Int32FieldType) {
            return String.format("writable.writeInt(%s)", name);
        } else if (type instanceof FieldType.Int64FieldType) {
            return String.format("writable.writeLong(%s)", name);
        } else if (type instanceof FieldType.StringFieldType) {
            if (nullable) {
                return String.format("writable.writeNullableString(%s)", name);
            } else {
                return String.format("writable.writeString(%s)", name);
            }
        } else if (type instanceof FieldType.BytesFieldType) {
            if (nullable) {
                return String.format("writable.writeNullableBytes(%s)", name);
            } else {
                return String.format("writable.writeBytes(%s)", name);
            }
        } else if (type instanceof FieldType.StructType) {
            return String.format("%s.write(writable, version)", name);
        } else {
            throw new RuntimeException("Unsupported field type " + type);
        }
    }

    private void generateFieldWriter(FieldSpec field, Versions curVersions) {
        if (field.type().isArray()) {
            boolean maybeAbsent =
                generateVersionCheck(curVersions, field.versions());
            boolean maybeNull = generateNullCheck(curVersions, field);
            if (maybeNull) {
                buffer.printf("writable.writeInt(-1);%n");
                buffer.decrementIndent();
                buffer.printf("} else {%n");
                buffer.incrementIndent();
            }
            buffer.printf("writable.writeInt(%s.size());%n", field.camelCaseName());
            FieldType.ArrayType arrayType = (FieldType.ArrayType) field.type();
            FieldType elementType = arrayType.elementType();
            String nestedTypeName = elementType.isStruct() ?
                elementType.toString() : getBoxedJavaType(elementType);
            buffer.printf("for (%s element : %s) {%n",
                nestedTypeName, field.camelCaseName());
            buffer.incrementIndent();
            buffer.printf("%s;%n", writeFieldToWritable(elementType, false, "element"));
            buffer.decrementIndent();
            buffer.printf("}%n");
            if (maybeNull) {
                buffer.decrementIndent();
                buffer.printf("}%n");
            }
            if (maybeAbsent) {
                buffer.decrementIndent();
                buffer.printf("}%n");
            }
        } else {
            boolean maybeAbsent =
                generateVersionCheck(curVersions, field.versions());
            buffer.printf("%s;%n", writeFieldToWritable(field.type(),
                !field.nullableVersions().empty(),
                field.camelCaseName()));
            if (maybeAbsent) {
                buffer.decrementIndent();
                buffer.printf("}%n");
            }
        }
    }

    private void generateClassToStruct(String className, StructSpec struct,
                                       Versions parentVersions) {
        headerGenerator.addImport(MessageGenerator.STRUCT_CLASS);
        buffer.printf("@Override%n");
        buffer.printf("public Struct toStruct(short version) {%n");
        buffer.incrementIndent();
        if (generateInverseVersionCheck(parentVersions, struct.versions())) {
            buffer.incrementIndent();
            headerGenerator.addImport(MessageGenerator.UNSUPPORTED_VERSION_EXCEPTION_CLASS);
            buffer.printf("throw new UnsupportedVersionException(\"Can't write " +
                "version \" + version + \" of %s\");%n", className);
            buffer.decrementIndent();
            buffer.printf("}%n");
        }
        Versions curVersions = parentVersions.intersect(struct.versions());
        if (curVersions.empty()) {
            throw new RuntimeException("Version ranges " + parentVersions +
                " and " + struct.versions() + " have no versions in common.");
        }
        buffer.printf("Struct struct = new Struct(SCHEMAS[version]);%n");
        for (FieldSpec field : struct.fields()) {
            generateFieldToStruct(field, curVersions);
        }
        buffer.printf("return struct;%n");
        buffer.decrementIndent();
        buffer.printf("}%n");
    }

    private void generateFieldToStruct(FieldSpec field, Versions curVersions) {
        if ((!field.type().canBeNullable()) &&
            (!field.nullableVersions().empty())) {
            throw new RuntimeException("Fields of type " + field.type() +
                " cannot be nullable.");
        }
        if ((field.type() instanceof FieldType.BoolFieldType) ||
                (field.type() instanceof FieldType.Int8FieldType) ||
                (field.type() instanceof FieldType.Int16FieldType) ||
                (field.type() instanceof FieldType.Int32FieldType) ||
                (field.type() instanceof FieldType.Int64FieldType) ||
                (field.type() instanceof FieldType.StringFieldType)) {
            boolean maybeAbsent =
                generateVersionCheck(curVersions, field.versions());
            buffer.printf("struct.set(\"%s\", this.%s);%n",
                field.snakeCaseName(), field.camelCaseName());
            if (maybeAbsent) {
                buffer.decrementIndent();
                buffer.printf("}%n");
            }
        } else if (field.type().isBytes()) {
            boolean maybeAbsent =
                generateVersionCheck(curVersions, field.versions());
            buffer.printf("struct.setByteArray(\"%s\", this.%s);%n",
                field.snakeCaseName(), field.camelCaseName());
            if (maybeAbsent) {
                buffer.decrementIndent();
                buffer.printf("}%n");
            }
        } else if (field.type().isArray()) {
            boolean maybeAbsent =
                generateVersionCheck(curVersions, field.versions());
            if (!maybeAbsent) {
                buffer.printf("{%n");
                buffer.incrementIndent();
            }
            boolean maybeNull = generateNullCheck(curVersions, field);
            if (maybeNull) {
                buffer.printf("struct.set(\"%s\", null);%n", field.snakeCaseName());
                buffer.decrementIndent();
                buffer.printf("} else {%n");
                buffer.incrementIndent();
            }
            FieldType.ArrayType arrayType = (FieldType.ArrayType) field.type();
            FieldType elementType = arrayType.elementType();
            String boxdElementType = elementType.isStruct() ? "Struct" : getBoxedJavaType(elementType);
            buffer.printf("%s[] nestedObjects = new %s[%s.size()];%n",
                boxdElementType, boxdElementType, field.camelCaseName());
            buffer.printf("int i = 0;%n");
            buffer.printf("for (%s element : this.%s) {%n",
                getBoxedJavaType(arrayType.elementType()), field.camelCaseName());
            buffer.incrementIndent();
            if (elementType.isStruct()) {
                buffer.printf("nestedObjects[i++] = element.toStruct(version);%n");
            } else {
                buffer.printf("nestedObjects[i++] = element;%n");
            }
            buffer.decrementIndent();
            buffer.printf("}%n");
            buffer.printf("struct.set(\"%s\", (Object[]) nestedObjects);%n",
                field.snakeCaseName());
            if (maybeNull) {
                buffer.decrementIndent();
                buffer.printf("}%n");
            }
            buffer.decrementIndent();
            buffer.printf("}%n");
        } else {
            throw new RuntimeException("Unsupported field type " + field.type());
        }
    }

    private void generateClassSize(String className, StructSpec struct,
                                   Versions parentVersions) {
        buffer.printf("@Override%n");
        buffer.printf("public int size(short version) {%n");
        buffer.incrementIndent();
        buffer.printf("int size = 0;%n");
        if (generateInverseVersionCheck(parentVersions, struct.versions())) {
            buffer.incrementIndent();
            headerGenerator.addImport(MessageGenerator.UNSUPPORTED_VERSION_EXCEPTION_CLASS);
            buffer.printf("throw new UnsupportedVersionException(\"Can't size " +
                "version \" + version + \" of %s\");%n", className);
            buffer.decrementIndent();
            buffer.printf("}%n");
        }
        Versions curVersions = parentVersions.intersect(struct.versions());
        if (curVersions.empty()) {
            throw new RuntimeException("Version ranges " + parentVersions +
                " and " + struct.versions() + " have no versions in common.");
        }
        for (FieldSpec field : struct.fields()) {
            generateFieldSize(field, curVersions);
        }
        buffer.printf("return size;%n");
        buffer.decrementIndent();
        buffer.printf("}%n");
    }

    private void generateVariableLengthFieldSize(String fieldName, FieldType type, boolean nullable) {
        if (type instanceof FieldType.StringFieldType) {
            buffer.printf("size += 2;%n");
            if (nullable) {
                buffer.printf("if (%s != null) {%n", fieldName);
                buffer.incrementIndent();
            }
            headerGenerator.addImport(MessageGenerator.MESSAGE_UTIL_CLASS);
            buffer.printf("size += MessageUtil.serializedUtf8Length(%s);%n", fieldName);
            if (nullable) {
                buffer.decrementIndent();
                buffer.printf("}%n");
            }
        } else if (type instanceof FieldType.BytesFieldType) {
            buffer.printf("size += 4;%n");
            if (nullable) {
                buffer.printf("if (%s != null) {%n", fieldName);
                buffer.incrementIndent();
            }
            buffer.printf("size += %s.length;%n", fieldName);
            if (nullable) {
                buffer.decrementIndent();
                buffer.printf("}%n");
            }
        } else if (type instanceof FieldType.StructType) {
            buffer.printf("size += %s.size(version);%n", fieldName);
        } else {
            throw new RuntimeException("Unsupported type " + type);
        }
    }

    private void generateFieldSize(FieldSpec field, Versions curVersions) {
        if (field.type().fixedLength().isPresent()) {
            boolean maybeAbsent =
                generateVersionCheck(curVersions, field.versions());
            buffer.printf("size += %d;%n", field.type().fixedLength().get());
            if (maybeAbsent) {
                buffer.decrementIndent();
                generateAbsentValueCheck(field);
            }
        } else if (field.type().isString() || field.type().isBytes() || field.type().isStruct()) {
            boolean nullable = !curVersions.intersect(field.nullableVersions()).empty();
            boolean maybeAbsent =
                generateVersionCheck(curVersions, field.versions());
            generateVariableLengthFieldSize(field.camelCaseName(), field.type(), nullable);
            if (maybeAbsent) {
                buffer.decrementIndent();
                generateAbsentValueCheck(field);
            }
        } else if (field.type().isArray()) {
            boolean maybeAbsent =
                generateVersionCheck(curVersions, field.versions());
            boolean maybeNull = generateNullCheck(curVersions, field);
            if (maybeNull) {
                buffer.printf("size += 4;%n");
                buffer.decrementIndent();
                buffer.printf("} else {%n");
                buffer.incrementIndent();
            }
            buffer.printf("size += 4;%n");
            FieldType.ArrayType arrayType = (FieldType.ArrayType) field.type();
            FieldType elementType = arrayType.elementType();
            if (elementType.fixedLength().isPresent()) {
                buffer.printf("size += %s.size() * %d;%n",
                    field.camelCaseName(),
                    elementType.fixedLength().get());
            } else if (elementType instanceof FieldType.ArrayType) {
                throw new RuntimeException("Arrays of arrays are not supported " +
                    "(use a struct).");
            } else {
                buffer.printf("for (%s element : %s) {%n",
                    getBoxedJavaType(elementType), field.camelCaseName());
                buffer.incrementIndent();
                generateVariableLengthFieldSize("element", elementType, false);
                buffer.decrementIndent();
                buffer.printf("}%n");
            }
            if (maybeNull) {
                buffer.decrementIndent();
                buffer.printf("}%n");
            }
            if (maybeAbsent) {
                buffer.decrementIndent();
                generateAbsentValueCheck(field);
            }
        } else {
            throw new RuntimeException("Unsupported field type " + field.type());
        }
    }

    private void generateAbsentValueCheck(FieldSpec field) {
        if (field.ignorable()) {
            buffer.printf("}%n");
            return;
        }
        buffer.printf("} else {%n");
        buffer.incrementIndent();
        headerGenerator.addImport(MessageGenerator.UNSUPPORTED_VERSION_EXCEPTION_CLASS);
        if (field.type().isArray()) {
            buffer.printf("if (!%s.isEmpty()) {%n", field.camelCaseName());
        } else if (field.type().isBytes()) {
            buffer.printf("if (%s.length != 0) {%n", field.camelCaseName());
        } else if (field.type().isString()) {
            if (fieldDefault(field).equals("null")) {
                buffer.printf("if (%s != null) {%n", field.camelCaseName());
            } else {
                buffer.printf("if (!%s.equals(%s)) {%n", field.camelCaseName(), fieldDefault(field));
            }
        } else if (field.type() instanceof FieldType.BoolFieldType) {
            buffer.printf("if (%s%s) {%n",
                fieldDefault(field).equals("true") ? "!" : "",
                field.camelCaseName());
        } else {
            buffer.printf("if (%s != %s) {%n", field.camelCaseName(), fieldDefault(field));
        }
        buffer.incrementIndent();
        buffer.printf("throw new UnsupportedVersionException(" +
                "\"Attempted to write a non-default %s at version \" + version);%n",
            field.camelCaseName());
        buffer.decrementIndent();
        buffer.printf("}%n");
        buffer.decrementIndent();
        buffer.printf("}%n");
    }

    private void generateClassEquals(String className, StructSpec struct, boolean onlyMapKeys) {
        buffer.printf("@Override%n");
        buffer.printf("public boolean equals(Object obj) {%n");
        buffer.incrementIndent();
        buffer.printf("if (!(obj instanceof %s)) return false;%n", className);
        if (!struct.fields().isEmpty()) {
            buffer.printf("%s other = (%s) obj;%n", className, className);
            for (FieldSpec field : struct.fields()) {
                if ((!onlyMapKeys) || field.mapKey()) {
                    generateFieldEquals(field);
                }
            }
        }
        buffer.printf("return true;%n");
        buffer.decrementIndent();
        buffer.printf("}%n");
    }

    private void generateFieldEquals(FieldSpec field) {
        if (field.type().isString() || field.type().isArray() || field.type().isStruct()) {
            buffer.printf("if (this.%s == null) {%n", field.camelCaseName());
            buffer.incrementIndent();
            buffer.printf("if (other.%s != null) return false;%n", field.camelCaseName());
            buffer.decrementIndent();
            buffer.printf("} else {%n");
            buffer.incrementIndent();
            buffer.printf("if (!this.%s.equals(other.%s)) return false;%n",
                field.camelCaseName(), field.camelCaseName());
            buffer.decrementIndent();
            buffer.printf("}%n");
        } else if (field.type().isBytes()) {
            // Arrays#equals handles nulls.
            headerGenerator.addImport(MessageGenerator.ARRAYS_CLASS);
            buffer.printf("if (!Arrays.equals(this.%s, other.%s)) return false;%n",
                field.camelCaseName(), field.camelCaseName());
        } else {
            buffer.printf("if (%s != other.%s) return false;%n",
                field.camelCaseName(), field.camelCaseName());
        }
    }

    private void generateClassHashCode(StructSpec struct, boolean onlyMapKeys) {
        buffer.printf("@Override%n");
        buffer.printf("public int hashCode() {%n");
        buffer.incrementIndent();
        buffer.printf("int hashCode = 0;%n");
        for (FieldSpec field : struct.fields()) {
            if ((!onlyMapKeys) || field.mapKey()) {
                generateFieldHashCode(field);
            }
        }
        buffer.printf("return hashCode;%n");
        buffer.decrementIndent();
        buffer.printf("}%n");
    }

    private void generateFieldHashCode(FieldSpec field) {
        if (field.type() instanceof FieldType.BoolFieldType) {
            buffer.printf("hashCode = 31 * hashCode + (%s ? 1231 : 1237);%n",
                field.camelCaseName());
        } else if ((field.type() instanceof FieldType.Int8FieldType) ||
                    (field.type() instanceof FieldType.Int16FieldType) ||
                    (field.type() instanceof FieldType.Int32FieldType)) {
            buffer.printf("hashCode = 31 * hashCode + %s;%n",
                field.camelCaseName());
        } else if (field.type() instanceof FieldType.Int64FieldType) {
            buffer.printf("hashCode = 31 * hashCode + ((int) (%s >> 32) ^ (int) %s);%n",
                field.camelCaseName(), field.camelCaseName());
        } else if (field.type().isString()) {
            buffer.printf("hashCode = 31 * hashCode + (%s == null ? 0 : %s.hashCode());%n",
                field.camelCaseName(), field.camelCaseName());
        } else if (field.type().isBytes()) {
            headerGenerator.addImport(MessageGenerator.ARRAYS_CLASS);
            buffer.printf("hashCode = 31 * hashCode + Arrays.hashCode(%s);%n",
                field.camelCaseName());
        } else if (field.type().isStruct() || field.type().isArray()) {
            buffer.printf("hashCode = 31 * hashCode + (%s == null ? 0 : %s.hashCode());%n",
                field.camelCaseName(), field.camelCaseName());
        } else {
            throw new RuntimeException("Unsupported field type " + field.type());
        }
    }

    private void generateClassToString(String className, StructSpec struct) {
        buffer.printf("@Override%n");
        buffer.printf("public String toString() {%n");
        buffer.incrementIndent();
        buffer.printf("return \"%s(\"%n", className);
        buffer.incrementIndent();
        String prefix = "";
        for (FieldSpec field : struct.fields()) {
            generateFieldToString(prefix, field);
            prefix = ", ";
        }
        buffer.printf("+ \")\";%n");
        buffer.decrementIndent();
        buffer.decrementIndent();
        buffer.printf("}%n");
    }

    private void generateFieldToString(String prefix, FieldSpec field) {
        if (field.type() instanceof FieldType.BoolFieldType) {
            buffer.printf("+ \"%s%s=\" + (%s ? \"true\" : \"false\")%n",
                prefix, field.camelCaseName(), field.camelCaseName());
        } else if ((field.type() instanceof FieldType.Int8FieldType) ||
                (field.type() instanceof FieldType.Int16FieldType) ||
                (field.type() instanceof FieldType.Int32FieldType) ||
                (field.type() instanceof FieldType.Int64FieldType)) {
            buffer.printf("+ \"%s%s=\" + %s%n",
                prefix, field.camelCaseName(), field.camelCaseName());
        } else if (field.type().isString()) {
            buffer.printf("+ \"%s%s='\" + %s + \"'\"%n",
                prefix, field.camelCaseName(), field.camelCaseName());
        } else if (field.type().isBytes()) {
            headerGenerator.addImport(MessageGenerator.ARRAYS_CLASS);
            buffer.printf("+ \"%s%s=\" + Arrays.toString(%s)%n",
                prefix, field.camelCaseName(), field.camelCaseName());
        } else if (field.type().isStruct()) {
            buffer.printf("+ \"%s%s=\" + %s.toString()%n",
                prefix, field.camelCaseName(), field.camelCaseName());
        } else if (field.type().isArray()) {
            headerGenerator.addImport(MessageGenerator.MESSAGE_UTIL_CLASS);
            if (field.nullableVersions().empty()) {
                buffer.printf("+ \"%s%s=\" + MessageUtil.deepToString(%s.iterator())%n",
                    prefix, field.camelCaseName(), field.camelCaseName());
            } else {
                buffer.printf("+ \"%s%s=\" + ((%s == null) ? \"null\" : " +
                    "MessageUtil.deepToString(%s.iterator()))%n",
                    prefix, field.camelCaseName(), field.camelCaseName(), field.camelCaseName());
            }
        } else {
            throw new RuntimeException("Unsupported field type " + field.type());
        }
    }

    private boolean generateNullCheck(Versions prevVersions, FieldSpec field) {
        if (prevVersions.intersect(field.nullableVersions()).empty()) {
            return false;
        }
        buffer.printf("if (%s == null) {%n", field.camelCaseName());
        buffer.incrementIndent();
        return true;
    }

    private boolean generateVersionCheck(Versions prev, Versions cur) {
        if (cur.lowest() > prev.lowest()) {
            if (cur.highest() < prev.highest()) {
                buffer.printf("if ((version >= %d) && (version <= %d)) {%n",
                    cur.lowest(), cur.highest());
                buffer.incrementIndent();
                return true;
            } else {
                buffer.printf("if (version >= %d) {%n", cur.lowest());
                buffer.incrementIndent();
                return true;
            }
        } else {
            if (cur.highest() < prev.highest()) {
                buffer.printf("if (version <= %d) {%n", cur.highest());
                buffer.incrementIndent();
                return true;
            } else {
                return false;
            }
        }
    }

    private boolean generateInverseVersionCheck(Versions prev, Versions cur) {
        if (cur.lowest() > prev.lowest()) {
            if (cur.highest() < prev.highest()) {
                buffer.printf("if ((version < %d) || (version > %d)) {%n",
                    cur.lowest(), cur.highest());
                return true;
            } else {
                buffer.printf("if (version < %d) {%n", cur.lowest());
                return true;
            }
        } else {
            if (cur.highest() < prev.highest()) {
                buffer.printf("if (version > %d) {%n", cur.highest());
                return true;
            } else {
                return false;
            }
        }
    }

    private void generateSetDefault(FieldSpec field) {
        buffer.decrementIndent();
        buffer.printf("} else {%n");
        buffer.incrementIndent();
        buffer.printf("this.%s = %s;%n", field.camelCaseName(), fieldDefault(field));
        buffer.decrementIndent();
        buffer.printf("}%n");
    }

    private String fieldDefault(FieldSpec field) {
        if (field.type() instanceof FieldType.BoolFieldType) {
            if (field.defaultString().isEmpty()) {
                return "false";
            } else if (field.defaultString().equalsIgnoreCase("true")) {
                return "true";
            } else if (field.defaultString().equalsIgnoreCase("false")) {
                return "false";
            } else {
                throw new RuntimeException("Invalid default for boolean field " +
                    field.name() + ": " + field.defaultString());
            }
        } else if (field.type() instanceof FieldType.Int8FieldType) {
            if (field.defaultString().isEmpty()) {
                return "(byte) 0";
            } else {
                try {
                    Byte.decode(field.defaultString());
                } catch (NumberFormatException e) {
                    throw new RuntimeException("Invalid default for int8 field " +
                        field.name() + ": " + field.defaultString(), e);
                }
                return "(byte) " + field.defaultString();
            }
        } else if (field.type() instanceof FieldType.Int16FieldType) {
            if (field.defaultString().isEmpty()) {
                return "(short) 0";
            } else {
                try {
                    Short.decode(field.defaultString());
                } catch (NumberFormatException e) {
                    throw new RuntimeException("Invalid default for int16 field " +
                        field.name() + ": " + field.defaultString(), e);
                }
                return "(short) " + field.defaultString();
            }
        } else if (field.type() instanceof FieldType.Int32FieldType) {
            if (field.defaultString().isEmpty()) {
                return "0";
            } else {
                try {
                    Integer.decode(field.defaultString());
                } catch (NumberFormatException e) {
                    throw new RuntimeException("Invalid default for int32 field " +
                        field.name() + ": " + field.defaultString(), e);
                }
                return field.defaultString();
            }
        } else if (field.type() instanceof FieldType.Int64FieldType) {
            if (field.defaultString().isEmpty()) {
                return "0L";
            } else {
                try {
                    Integer.decode(field.defaultString());
                } catch (NumberFormatException e) {
                    throw new RuntimeException("Invalid default for int64 field " +
                        field.name() + ": " + field.defaultString(), e);
                }
                return field.defaultString() + "L";
            }
        } else if (field.type() instanceof FieldType.StringFieldType) {
            if (field.defaultString().equals("null")) {
                if (!(field.nullableVersions().contains(field.versions()))) {
                    throw new RuntimeException("null cannot be the default for field " +
                        field.name() + ", because not all versions of this field are " +
                        "nullable.");
                }
                return "null";
            } else {
                return "\"" + field.defaultString() + "\"";
            }
        } else if (field.type().isBytes()) {
            if (!field.defaultString().isEmpty()) {
                throw new RuntimeException("Invalid default for bytes field " +
                    field.name() + ": custom defaults are not supported for bytes fields.");
            }
            headerGenerator.addImport(MessageGenerator.BYTES_CLASS);
            return "Bytes.EMPTY";
        } else if (field.type().isStruct()) {
            if (!field.defaultString().isEmpty()) {
                throw new RuntimeException("Invalid default for struct field " +
                    field.name() + ": custom defaults are not supported for struct fields.");
            }
            return "new " + field.type().toString() + "()";
        } else if (field.type().isArray()) {
            if (!field.defaultString().isEmpty()) {
                throw new RuntimeException("Invalid default for array field " +
                    field.name() + ": custom defaults are not supported for array fields.");
            }
            FieldType.ArrayType arrayType = (FieldType.ArrayType) field.type();
            if (field.toStruct().hasKeys()) {
                return "new " + collectionType(arrayType.elementType().toString()) + "(0)";
            } else {
                headerGenerator.addImport(MessageGenerator.ARRAYLIST_CLASS);
                return "new ArrayList<" + getBoxedJavaType(arrayType.elementType()) + ">()";
            }
        } else {
            throw new RuntimeException("Unsupported field type " + field.type());
        }
    }

    private void generateFieldAccessor(FieldSpec field) {
        buffer.printf("%n");
        generateAccessor(fieldAbstractJavaType(field), field.camelCaseName(),
            field.camelCaseName());
    }

    private void generateAccessor(String javaType, String functionName, String memberName) {
        buffer.printf("public %s %s() {%n", javaType, functionName);
        buffer.incrementIndent();
        buffer.printf("return this.%s;%n", memberName);
        buffer.decrementIndent();
        buffer.printf("}%n");
    }

    private void generateFieldMutator(String className, FieldSpec field) {
        buffer.printf("%n");
        buffer.printf("public %s set%s(%s v) {%n",
            className,
            field.capitalizedCamelCaseName(),
            fieldAbstractJavaType(field));
        buffer.incrementIndent();
        buffer.printf("this.%s = v;%n", field.camelCaseName());
        buffer.printf("return this;%n");
        buffer.decrementIndent();
        buffer.printf("}%n");
    }

    private void generateSetter(String javaType, String functionName, String memberName) {
        buffer.printf("public void %s(%s v) {%n", functionName, javaType);
        buffer.incrementIndent();
        buffer.printf("this.%s = v;%n", memberName);
        buffer.decrementIndent();
        buffer.printf("}%n");
    }
}