net.zerobuilder.compiler.generate.DtoRegularGoalDescription 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.TypeName;
import net.zerobuilder.compiler.generate.DtoGoalDetails.AbstractRegularDetails;
import net.zerobuilder.compiler.generate.DtoGoalDetails.ProjectableDetails;
import net.zerobuilder.compiler.generate.DtoProjectedDescription.ProjectedDescription;
import net.zerobuilder.compiler.generate.DtoProjectedDescription.ProjectedDescriptionCases;
import net.zerobuilder.compiler.generate.DtoRegularParameter.AbstractRegularParameter;
import net.zerobuilder.compiler.generate.DtoRegularParameter.ProjectedParameter;
import net.zerobuilder.compiler.generate.DtoRegularParameter.SimpleParameter;
import net.zerobuilder.compiler.generate.DtoSimpleDescription.SimpleDescription;

import java.util.List;
import java.util.function.Function;

import static java.util.Collections.unmodifiableList;
import static net.zerobuilder.compiler.generate.DtoGoalDetails.parameterNames;

public final class DtoRegularGoalDescription {

  interface AbstractRegularGoalDescriptionCases {
    R acceptSimple(SimpleRegularGoalDescription simple);
    R acceptProjected(ProjectedRegularGoalDescription projected);
  }

  static  Function asFunction(AbstractRegularGoalDescriptionCases cases) {
    return description -> description.acceptRegularGoalDescription(cases);
  }

  static  Function regularGoalDescriptionCases(
      Function simpleFunction,
      Function projectedFunction) {
    return asFunction(new AbstractRegularGoalDescriptionCases() {
      @Override
      public R acceptSimple(SimpleRegularGoalDescription simple) {
        return simpleFunction.apply(simple);
      }
      @Override
      public R acceptProjected(ProjectedRegularGoalDescription projected) {
        return projectedFunction.apply(projected);
      }
    });
  }

  public static abstract class AbstractRegularGoalDescription {
    final AbstractRegularDetails details;
    final List thrownTypes;
    final List parameters() {
      return abstractParameters.apply(this);
    }

    protected AbstractRegularGoalDescription(AbstractRegularDetails details, List thrownTypes) {
      this.details = details;
      this.thrownTypes = thrownTypes;
    }

    abstract  R acceptRegularGoalDescription(AbstractRegularGoalDescriptionCases cases);
  }


  private static final Function> abstractParameters =
      regularGoalDescriptionCases(
          simple -> unmodifiableList(simple.parameters),
          projected -> unmodifiableList(projected.parameters));


  /**
   * Describes of a goal that represents either a static method or an instance method, or a constructor.
   */
  public static final class SimpleRegularGoalDescription extends AbstractRegularGoalDescription
      implements SimpleDescription {

    final List parameters;

    private SimpleRegularGoalDescription(AbstractRegularDetails details,
                                         List thrownTypes,
                                         List parameters) {
      super(details, thrownTypes);
      this.parameters = parameters;
    }

    public static SimpleRegularGoalDescription create(AbstractRegularDetails details,
                                                      List thrownTypes,
                                                      List parameters) {
      checkParameterNames(details.parameterNames, parameters);
      return new SimpleRegularGoalDescription(details, thrownTypes, parameters);
    }

    @Override
     R acceptRegularGoalDescription(AbstractRegularGoalDescriptionCases cases) {
      return cases.acceptSimple(this);
    }

    @Override
    public  R acceptSimple(DtoSimpleDescription.SimpleDescriptionCases cases) {
      return cases.regular(this);
    }
  }

  /**
   * Describes of a goal that represents either a static method or an instance method, or a constructor.
   */
  public static final class ProjectedRegularGoalDescription
      implements ProjectedDescription {
    final List parameters;
    final ProjectableDetails details;
    final List thrownTypes;


    private ProjectedRegularGoalDescription(ProjectableDetails details,
                                            List thrownTypes,
                                            List parameters) {
      this.details = details;
      this.thrownTypes = thrownTypes;
      this.parameters = parameters;
    }

    public static ProjectedRegularGoalDescription create(ProjectableDetails details,
                                                         List thrownTypes,
                                                         List parameters) {
      checkParameterNames(parameterNames.apply(details), parameters);
      return new ProjectedRegularGoalDescription(details, thrownTypes, parameters);
    }

    @Override
    public  R acceptProjected(ProjectedDescriptionCases cases) {
      return cases.regular(this);
    }
  }

  private static void checkParameterNames(List parameterNames,
                                          List parameters) {
    if (parameters.isEmpty()) {
      throw new IllegalArgumentException("need at least one parameter");
    }
    if (parameterNames.size() != parameters.size()) {
      throw new IllegalArgumentException("parameter names mismatch");
    }
    int[] positions = new int[parameterNames.size()];
    for (AbstractRegularParameter parameter : parameters) {
      int i = parameterNames.indexOf(parameter.name);
      if (positions[i]++ != 0) {
        throw new IllegalArgumentException("parameter names mismatch");
      }
    }
  }


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