com.github.dakusui.jcunit8.factorspace.SequenceParameterFactoryBuilder Maven / Gradle / Ivy

Go to download
package com.github.dakusui.jcunit8.factorspace;

import com.github.dakusui.jcunit.core.tuples.Tuple;
import com.github.dakusui.jcunit.core.utils.Checks;
import com.github.dakusui.jcunit8.core.Utils;

import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import static com.github.dakusui.jcunit8.pipeline.stages.Generator.VOID;
import static java.util.stream.Collectors.toList;

public class SequenceParameterFactoryBuilder {
  private final List elements;
  private       int     min;
  private       int     max;
  private boolean withRepetition = true;

  public SequenceParameterFactoryBuilder(List elements) {
    this.elements = elements;
  }

  public SequenceParameterFactoryBuilder size(int min, int max) {
    Checks.checkcond(min >= 0);
    Checks.checkcond(max > 0);
    Checks.checkcond(max >= min);
    this.min = min;
    this.max = max;
    return this;
  }

  public SequenceParameterFactoryBuilder size(int max) {
    return this.size(0, max);
  }

  public SequenceParameterFactoryBuilder withRepetition() {
    return this.withRepetition(true);
  }

  public SequenceParameterFactoryBuilder withRepetition(boolean enabled) {
    this.withRepetition = enabled;
    return this;
  }

  public SequenceParameterFactoryBuilder withoutRepetition() {
    return this.withRepetition(false);
  }

  public Parameter.Factory> build() {
    return new Parameter.Factory.Base>() {
      @Override
      public Parameter> create(String name) {
        return new Parameter.Base>(name, knownValues) {
          @Override
          protected List decompose() {
            return new LinkedList() {
              {
                addAll(
                    IntStream.range(0, max).boxed(
                    ).map(
                        i -> Factor.create(
                            composeValueFactorName(i),
                            i < min ?
                                elements.toArray() :
                                Stream.concat(elements.stream(), Stream.of(VOID)).toArray()
                        )
                    ).collect(
                        toList()
                    )
                );
                add(
                    Factor.create(
                        composeSizeFactorName(),
                        IntStream.range(min, max + 1).boxed().toArray()
                    )
                );
              }
            };
          }

          @Override
          protected List generateConstraints() {
            return new LinkedList() {{
              add(new Constraint() {
                @Override
                public String getName() {
                  return String.format("excludeIllegalVoids:%s", involvedKeys());
                }

                @Override
                public boolean test(Tuple tuple) {
                  int size = getSizeFromTuple(tuple);
                  for (int i = min; i < max; i++) {
                    if (i < size) {
                      if (Objects.equals(getValueFromTuple(tuple, i), VOID))
                        return false;
                    } else if (!Objects.equals(tuple.get(composeValueFactorName(i)), VOID))
                      return false;
                  }
                  return true;
                }

                @Override
                public List involvedKeys() {
                  return composeInvolvedKeys(min, max);
                }
              });
              if (!withRepetition) {
                add(new Constraint() {
                  @Override
                  public String getName() {
                    return String.format("forRepetition:%s", involvedKeys());
                  }

                  @Override
                  public boolean test(Tuple tuple) {
                    List