org.ggp.base.util.gdl.model.CartesianSentenceFormDomain Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of alloy-ggp-base Show documentation
A modified version of the GGP-Base library for Alloy.
The newest version!
package org.ggp.base.util.gdl.model;

import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.ggp.base.util.gdl.grammar.GdlConstant;
import org.ggp.base.util.gdl.grammar.GdlSentence;

import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.base.Supplier;
import com.google.common.base.Suppliers;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterators;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.SetMultimap;
import com.google.common.collect.Sets;

/**
 * A {@link SentenceFormDomain} implementation that stores which
 * constant values are possible for each slot of a sentence form.
 *
 * This is a more compact representation than a {@link FullSentenceFormDomain},
 * but has less expressive power.
 */
public class CartesianSentenceFormDomain implements SentenceFormDomain {
    private final SentenceForm form;
    private final ImmutableList> domainsForSlots;
    private final Supplier sizeSupplier;

    private CartesianSentenceFormDomain(SentenceForm form,
            ImmutableList> domainsForSlots) {
        this.form = form;
        this.domainsForSlots = domainsForSlots;
        this.sizeSupplier = Suppliers.memoize(() -> {
            return domainsForSlots.stream()
                    .mapToInt(Set::size)
                    .reduce(1, (x, y) -> x*y);
        });
    }

    public static CartesianSentenceFormDomain create(SentenceForm form,
            List> domainsForSlots) {
        return new CartesianSentenceFormDomain(form,
                ImmutableList.copyOf(Lists.transform(domainsForSlots,
                        new Function, ImmutableSet>() {
                    @Override
                    public ImmutableSet apply(Set input) {
                        return ImmutableSet.copyOf(input);
                    }
                })));
    }

    public static SentenceFormDomain create(SentenceForm form,
            SetMultimap setMultimap) {
        Preconditions.checkNotNull(setMultimap);

        List> domainsForSlots = Lists.newArrayList();
        for (int i = 0; i < form.getTupleSize(); i++) {
            domainsForSlots.add(setMultimap.get(i));
        }
        return create(form, domainsForSlots);
    }

    @Override
    public Iterator iterator() {
        return Iterators.transform(Sets.cartesianProduct(domainsForSlots).iterator(),
                new Function, GdlSentence>() {
            @Override
            public GdlSentence apply(List input) {
                return form.getSentenceFromTuple(input);
            }
        });
    }

    @Override
    public SentenceForm getForm() {
        return form;
    }

    @Override
    public Set getDomainForSlot(int slotIndex) {
        Preconditions.checkElementIndex(slotIndex, form.getTupleSize());
        return domainsForSlots.get(slotIndex);
    }

    @Override
    public String toString() {
        return "CartesianSentenceFormDomain [form=" + form
                + ", domainsForSlots=" + domainsForSlots + "]";
    }

    @Override
    public Map> getDomainsForSlotGivenValuesOfOtherSlot(
            int slotOfInterest, int inputSlot) {
        return getCartesianMapForDomains(getDomainForSlot(inputSlot),
                getDomainForSlot(slotOfInterest));
    }

    public static Map> getCartesianMapForDomains(
            Set inputSlotDomain, Set outputSlotDomain) {
        Map> result = Maps.newHashMapWithExpectedSize(inputSlotDomain.size());
        for (GdlConstant inputValue : inputSlotDomain) {
            result.put(inputValue, outputSlotDomain);
        }
        return result;
    }

    @Override
    public int getDomainSize() {
        return sizeSupplier.get();
    }
}