net.zerobuilder.compiler.generate.DtoRegularStep Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of zerobuilder-api Show documentation
There is a newer version: 1.603
package net.zerobuilder.compiler.generate;

import com.squareup.javapoet.FieldSpec;
import com.squareup.javapoet.TypeName;
import net.zerobuilder.compiler.generate.DtoContext.BuildersContext;
import net.zerobuilder.compiler.generate.DtoGoalDetails.AbstractGoalDetails;
import net.zerobuilder.compiler.generate.DtoRegularParameter.AbstractRegularParameter;
import net.zerobuilder.compiler.generate.DtoRegularParameter.ProjectedParameter;
import net.zerobuilder.compiler.generate.DtoRegularParameter.SimpleParameter;

import java.util.List;
import java.util.Optional;
import java.util.function.Supplier;

import static java.util.Collections.emptyList;
import static javax.lang.model.element.Modifier.PRIVATE;
import static net.zerobuilder.compiler.generate.ZeroUtil.fieldSpec;
import static net.zerobuilder.compiler.generate.ZeroUtil.memoize;

public final class DtoRegularStep {

  public static abstract class AbstractRegularStep extends DtoStep.AbstractStep {

    protected AbstractRegularStep(String thisType,
                                  Optional nextType,
                                  AbstractGoalDetails goalDetails,
                                  BuildersContext context) {
      super(thisType, nextType, goalDetails, context);
    }

    public abstract Optional collectionInfo();
    public abstract FieldSpec field();
    public abstract AbstractRegularParameter regularParameter();
    public abstract List declaredExceptions();

    @Override
    final  R accept(DtoStep.StepCases cases) {
      return cases.regularStep(this);
    }
  }

  public static final class ProjectedRegularStep extends AbstractRegularStep {
    final ProjectedParameter parameter;
    final List declaredExceptions;

    private final Supplier field;
    private final Supplier> collectionInfo;

    private ProjectedRegularStep(String thisType,
                                 Optional nextType,
                                 AbstractGoalDetails goalDetails,
                                 BuildersContext context,
                                 ProjectedParameter parameter,
                                 List declaredExceptions,
                                 Supplier field,
                                 Supplier> collectionInfo) {
      super(thisType, nextType, goalDetails, context);
      this.declaredExceptions = declaredExceptions;
      this.parameter = parameter;
      this.field = field;
      this.collectionInfo = collectionInfo;
    }

    static ProjectedRegularStep create(String thisType,
                                       Optional nextType,
                                       AbstractGoalDetails goalDetails,
                                       BuildersContext context,
                                       ProjectedParameter parameter,
                                       List declaredExceptions) {
      return new ProjectedRegularStep(thisType, Optional.ofNullable(nextType.orElse(null)), goalDetails, context, parameter, declaredExceptions,
          memoizeField(parameter), memoizeCollectionInfo(parameter));
    }

    @Override
    public Optional collectionInfo() {
      return collectionInfo.get();
    }

    @Override
    public FieldSpec field() {
      return field.get();
    }

    @Override
    public AbstractRegularParameter regularParameter() {
      return parameter;
    }

    @Override
    public List declaredExceptions() {
      return declaredExceptions;
    }
  }

  static final class SimpleRegularStep extends AbstractRegularStep {

    final SimpleParameter parameter;
    private final Supplier field;
    private final Supplier> collectionInfo;

    private SimpleRegularStep(String thisType,
                              Optional nextType,
                              AbstractGoalDetails goalDetails,
                              BuildersContext context,
                              SimpleParameter parameter,
                              Supplier field,
                              Supplier> collectionInfo) {
      super(thisType, nextType, goalDetails, context);
      this.parameter = parameter;
      this.field = field;
      this.collectionInfo = collectionInfo;
    }

    static SimpleRegularStep create(String thisType,
                                    Optional nextType,
                                    AbstractGoalDetails goalDetails,
                                    BuildersContext context,
                                    SimpleParameter parameter) {
      return new SimpleRegularStep(thisType, Optional.ofNullable(nextType.orElse(null)), goalDetails, context, parameter,
          memoizeField(parameter), memoizeCollectionInfo(parameter));
    }

    @Override
    public Optional collectionInfo() {
      return collectionInfo.get();
    }

    @Override
    public FieldSpec field() {
      return field.get();
    }

    @Override
    public AbstractRegularParameter regularParameter() {
      return parameter;
    }

    @Override
    public List declaredExceptions() {
      return emptyList();
    }
  }

  private static Supplier> memoizeCollectionInfo(
      AbstractRegularParameter parameter) {
    return memoize(() ->
        DtoStep.CollectionInfo.create(parameter.type, parameter.name));
  }

  private static Supplier memoizeField(AbstractRegularParameter parameter) {
    return memoize(() ->
        fieldSpec(parameter.type, parameter.name, PRIVATE));
  }

  private DtoRegularStep() {
    throw new UnsupportedOperationException("no instances");
  }
}