source: java2python/geniuswebtranslator/geniuswebsrc/geniusweb/bidspace/AllPartialBidsList.java@ 868

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 org.eclipse.jdt.annotation.NonNull;

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;

/**
 * Special NOVALUE vlaue, indicating that an issue is not set to any value. This
 * is to support partial bids internally, while still associating a value to all
 * issues.
 *
 */
class NoValue implements Value {
        // the single instance.
        public static @NonNull Value NOVALUE = new NoValue();

        private NoValue() {
        }

        @Override
        public @NonNull Object getValue() {
                return 0;
        }

}

/**
 * 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<@NonNull Bid> {

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

        @SuppressWarnings("unused")
        /**
         * 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} not null
         */
        public AllPartialBidsList(@NonNull Domain domain) {
                if (domain == null)
                        throw new IllegalArgumentException("domain=null");
                issues = new ArrayList<>(domain.getIssuesValues().keySet());

                /*#PY 
                 * values = [ ValueSetWithNull(domain.getValues(issue))  
                 *   for issue in issues ]
                 */
                List<ImmutableList<@NonNull Value>> values = issues.stream()
                                .map(issue -> new ValueSetWithNull(domain.getValues(issue)))
                                .collect(Collectors.toList());

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

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

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

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

}

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

        private @NonNull ValueSet valueset;

        /**
         * @param valueset a standard {@link ValueSet} not containing null
         */
        public ValueSetWithNull(@NonNull ValueSet valueset) {
                this.valueset = valueset;
        }

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

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

        @Override
        public boolean contains(@NonNull Value value) {
                if (value == NoValue.NOVALUE)
                        return true;
                return valueset.contains(value);
        }

}