gson-compile/gson-compile-processor/src/main/java/io/gitlab/jfronny/gson/compile/processor/adapter/AdapterAdapter.java

package io.gitlab.jfronny.gson.compile.processor.adapter;

import com.squareup.javapoet.*;
import io.gitlab.jfronny.gson.compile.processor.Const;
import io.gitlab.jfronny.gson.compile.processor.TypeHelper;

import javax.lang.model.type.TypeMirror;
import java.lang.reflect.ParameterizedType;
import java.util.Iterator;
import java.util.List;

public abstract class AdapterAdapter extends Adapter {
    @Override
    public void generateWrite(Runnable writeGet) {
        code.add(getAdapter() + ".write(writer, ");
        writeGet.run();
        code.add(");\n");
    }

    @Override
    public void generateRead() {
        code.add(getAdapter() + ".read(reader)");
    }

    private String getAdapter() {
        String typeAdapterName = Const.ADAPTER_PREFIX + property.getName();
        for (FieldSpec spec : klazz.fieldSpecs) {
            if (spec.name.equals(typeAdapterName)) return typeAdapterName;
        }
        return createAdapter(typeAdapterName);
    }

    protected abstract String createAdapter(String name);

    protected void appendFieldTypeToken(boolean allowClassType) {
        TypeMirror type = property.getType();
        TypeName typeName = TypeName.get(type);

        if (TypeHelper.isComplexType(type, typeUtils)) {
            TypeName typeTokenType = ParameterizedTypeName.get(Const.TYPE_TOKEN, typeName);
            List<? extends TypeMirror> typeParams = TypeHelper.getGenericTypes(type);
            if (typeParams.isEmpty()) {
                code.add("new $T() {}", typeTokenType);
            } else {
                code.add("($T) $T.getParameterized($T.class, ", typeTokenType, Const.TYPE_TOKEN, typeUtils.erasure(type));
                for (Iterator<? extends TypeMirror> iterator = typeParams.iterator(); iterator.hasNext(); ) {
                    TypeMirror typeParam = iterator.next();
                    int typeIndex = typeVariables.indexOf(TypeVariableName.get(typeParam.toString()));
                    code.add("(($T)typeToken.getType()).getActualTypeArguments()[$L]", ParameterizedType.class, typeIndex);
                    if (iterator.hasNext()) {
                        code.add(", ");
                    }
                }
                code.add(")");
            }
        } else if (TypeHelper.isGenericType(type)) {
            TypeName typeTokenType = ParameterizedTypeName.get(Const.TYPE_TOKEN, typeName);
            int typeIndex = typeVariables.indexOf(TypeVariableName.get(property.getType().toString()));
            code.add("($T) $T.get((($T)typeToken.getType()).getActualTypeArguments()[$L])",
                    typeTokenType, Const.TYPE_TOKEN, ParameterizedType.class, typeIndex);
        } else {
            if (allowClassType) {
                code.add("$T.class", typeName);
            } else {
                code.add("TypeToken.get($T.class)", typeName);
            }
        }
    }
}