com.kenshoo.pl.entity.internal.audit.AuditedFieldSet Maven / Gradle / Ivy

Go to download
package com.kenshoo.pl.entity.internal.audit;

import com.google.common.collect.ImmutableSet;
import com.kenshoo.pl.entity.EntityField;
import com.kenshoo.pl.entity.EntityType;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.jooq.lambda.Seq;

import java.util.Set;
import java.util.stream.Stream;

import static java.util.Collections.emptySet;
import static java.util.Collections.singleton;
import static java.util.Objects.requireNonNull;

public class AuditedFieldSet> {

    private final EntityField idField;
    private final Set> ancestorFields;
    private final Set> dataFields;

    private AuditedFieldSet(final EntityField idField,
                            final Set> ancestorFields,
                            final Set> dataFields) {
        this.idField = idField;
        this.ancestorFields = ancestorFields;
        this.dataFields = dataFields;
    }

    public EntityField getIdField() {
        return idField;
    }

    public Set> getAncestorFields() {
        return ancestorFields;
    }

    public Set> getDataFields() {
        return dataFields;
    }

    public Stream> getAllFields() {
        return Stream.of(singleton(idField),
                         ancestorFields,
                         dataFields)
                     .flatMap(Set::stream);
    }

    public AuditedFieldSet intersectWith(final Stream> fields) {
        return builder(idField)
            .withAncestorFields(ancestorFields)
            .withDataFields(Seq.seq(fields).filter(dataFields::contains))
            .build();
    }

    public static > Builder builder(final EntityField idField) {
        return new Builder<>(idField);
    }

    public static class Builder> {
        private final EntityField idField;
        private Set> ancestorFields = emptySet();
        private Set> dataFields = emptySet();

        public Builder(EntityField idField) {
            this.idField = requireNonNull(idField, "idField is required");
        }

        public Builder withAncestorFields(final Iterable> ancestorFields) {
            this.ancestorFields = ancestorFields == null ? emptySet() : ImmutableSet.copyOf(ancestorFields);
            return this;
        }

        public Builder withDataFields(final Iterable> dataFields) {
            this.dataFields = dataFields == null ? emptySet() : ImmutableSet.copyOf(dataFields);
            return this;
        }

        public AuditedFieldSet build() {
            return new AuditedFieldSet<>(idField, ancestorFields, dataFields);
        }
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }

        if (o == null || getClass() != o.getClass()) {
            return false;
        }

        final AuditedFieldSet that = (AuditedFieldSet) o;

        return new EqualsBuilder()
            .append(idField, that.idField)
            .append(ancestorFields, that.ancestorFields)
            .append(dataFields, that.dataFields)
            .isEquals();
    }

    @Override
    public int hashCode() {
        return new HashCodeBuilder(17, 37)
            .append(idField)
            .append(ancestorFields)
            .append(dataFields)
            .toHashCode();
    }

    @Override
    public String toString() {
        return new ToStringBuilder(this)
            .append("idField", idField)
            .append("ancestorFields", ancestorFields)
            .append("dataFields", dataFields)
            .toString();
    }

}