source: bidspace/src/main/java/geniusweb/bidspace/AllPartialBidsList.java@ 52

package geniusweb.bidspace;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.Domain;
import geniusweb.issuevalue.Value;
import geniusweb.issuevalue.ValueSet;
import tudelft.utilities.immutablelist.AbstractImmutableList;
import tudelft.utilities.immutablelist.ImmutableList;
import tudelft.utilities.immutablelist.Outer;

/**
 * A list containing all bids, both complete and partial, in the space. This is
 * an {@link ImmutableList} so it contains all bids without pre-computing them.
 * Constructing this is very cheap.
 * 
 */
public class AllPartialBidsList extends AbstractImmutableList<Bid> {

        private final List<String> issues;
        private final Outer<? extends Value> allValuePermutations;

        /**
         * A list containing all partial bids (this includes complete bids) in the
         * space. This is an ImmutableList so it can contain all bids without
         * pre-computing them.
         * 
         * @param domain the {@link Domain}
         */
        public AllPartialBidsList(Domain domain) {
                if (domain == null)
                        throw new IllegalArgumentException("domain=null");
                issues = new ArrayList<>(domain.getIssues());

                List<ImmutableList<Value>> values = issues.stream()
                                .map(issue -> new ValueSetWithNull(domain.getValues(issue)))
                                .collect(Collectors.toList());

                allValuePermutations = new Outer<Value>(values);
        }

        @Override
        public Bid get(BigInteger index) {
                ImmutableList<? extends Value> nextValues = allValuePermutations
                                .get(index);

                Map<String, Value> issueValues = new HashMap<>();
                for (int n = 0; n < issues.size(); n++) {
                        Value value = nextValues.get(BigInteger.valueOf(n));
                        if (value != null) {
                                issueValues.put(issues.get(n), value);
                        }
                }
                return new Bid(issueValues);
        }

        @Override
        public BigInteger size() {
                return allValuePermutations.size();
        }

}

/**
 * Extends a ValueSet so that the first element is null. Of course null is not a
 * good value, we catch it to use it as 'value not set'.
 *
 */
class ValueSetWithNull extends AbstractImmutableList<Value>
                implements ValueSet {

        private ValueSet valueset;

        public ValueSetWithNull(ValueSet valueset) {
                this.valueset = valueset;
        }

        @Override
        public Value get(BigInteger index) {
                if (BigInteger.ZERO.equals(index)) {
                        return null;
                }
                return valueset.get(index.subtract(BigInteger.ONE));
        }

        @Override
        public BigInteger size() {
                return BigInteger.ONE.add(valueset.size());
        }

        @Override
        public Boolean contains(Value value) {
                if (value == null)
                        return true;
                return valueset.contains(value);
        }

}