net.openhft.chronicle.testframework.internal.dto.DtoTesterBuilder Maven / Gradle / Ivy

Go to download
package net.openhft.chronicle.testframework.internal.dto;

import net.openhft.chronicle.testframework.dto.DtoTester;
import org.jetbrains.annotations.NotNull;

import java.util.ArrayList;
import java.util.List;
import java.util.function.*;

import static java.util.Collections.unmodifiableList;
import static java.util.Objects.requireNonNull;

public final class DtoTesterBuilder implements DtoTester.Builder {

    @NotNull
    private final Class type;
    @NotNull
    private final Supplier supplier;
    @NotNull
    private final List> mandatoryMutators;
    @NotNull
    private final List> optionalMutators;
    @NotNull
    private final List> validations;

    private Consumer resetter;
    private Consumer validator;

    public DtoTesterBuilder(@NotNull final Class type,
                            @NotNull final Supplier supplier) {
        this.type = requireNonNull(type);
        this.supplier = requireNonNull(supplier);
        mandatoryMutators = newList();
        optionalMutators = newList();
        validations = newList();
    }

    @Override
    @NotNull
    public  DtoTester.Builder withAccessors(@NotNull final Function getter,
                                                  @NotNull final BiConsumer setter) {
        requireNonNull(getter);
        requireNonNull(setter);
        // Do nothing at the moment.
        return this;
    }

    @Override
    @NotNull
    public DtoTester.Builder withResetter(@NotNull final Consumer resetter) {
        this.resetter = requireNonNull(resetter);
        return this;
    }

    @Override
    @NotNull
    public DtoTester.Builder withValidator(@NotNull final Consumer validator) {
        this.validator = validator;
        return this;
    }

    @Override
    @NotNull
    public  DtoTester.Builder addMutator(@NotNull final DtoTester.MutatorType type,
                                               @NotNull final String mutatorName,
                                               @NotNull final Consumer mutator) {
        switch (type) {
            case MANDATORY: {
                mandatoryMutators.add(new NamedMutator<>(mutatorName, mutator));
                break;
            }
            case OPTIONAL: {
                optionalMutators.add(new NamedMutator<>(mutatorName, mutator));
                break;
            }
            default:
                throw new IllegalStateException(type.toString());
        }
        return this;
    }
/*

    @Override
    @NotNull
    public DtoTester.Builder addValidationRule(@NotNull final String ruleName,
                                                  @NotNull final Predicate validator) {
        validations.add(new NamedPredicate<>(ruleName, validator));
        return this;
    }

 */

    @Override
    public DtoTester build() {
        return new StandardDtoTester<>(this);
    }

    Class type() {
        return type;
    }

    Supplier supplier() {
        return supplier;
    }

    List> mandatoryMutators() {
        return unmodifiableList(mandatoryMutators);
    }

    List> optionalMutators() {
        return unmodifiableList(optionalMutators);
    }

    List> allMutators() {
        final List> all = newList();
        all.addAll(mandatoryMutators);
        all.addAll(optionalMutators);
        return unmodifiableList(all);
    }

    List> validations() {
        return unmodifiableList(validations);
    }

    Consumer resetter() {
        return resetter;
    }

    Consumer validator() {
        return validator;
    }

    private  List newList() {
        return new ArrayList<>();
    }

    static final class NamedMutator extends AbstractNamedHolderRecord> {
        public NamedMutator(@NotNull final String name,
                            @NotNull final Consumer mutator) {
            super(name, mutator);
        }

        Consumer mutator() {
            return holder();
        }
    }

    static final class NamedPredicate extends AbstractNamedHolderRecord> {

        public NamedPredicate(@NotNull final String name,
                              @NotNull final Predicate predicate) {
            super(name, predicate);
        }

        Predicate predicate() {
            return holder();
        }
    }

    abstract static class AbstractNamedHolderRecord {
        @NotNull
        private final String name;
        @NotNull
        private final H holder;

        public AbstractNamedHolderRecord(@NotNull final String name,
                                         @NotNull final H holder) {
            this.name = requireNonNull(name);
            this.holder = requireNonNull(holder);
        }

        String name() {
            return name;
        }

        protected H holder() {
            return holder;
        }

        @Override
        public String toString() {
            return "{" +
                    "name='" + name + '\'' +
                    ", holder=" + holder +
                    '}';
        }
    }
}