source: java2python/geniuswebtranslator/geniuswebsrc/geniusweb/bidspace/AllBidsList.java@ 854

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 tudelft.utilities.immutablelist.AbstractImmutableList;
import tudelft.utilities.immutablelist.ImmutableList;
import tudelft.utilities.immutablelist.Outer;

/**
 * A list containing all complete bids in the space. This is an
 * {@link ImmutableList} so it can contain all bids without pre-computing them.
 * 
 */
public class AllBidsList extends AbstractImmutableList<@NonNull Bid> {

        private final @NonNull List<@NonNull String> issues = new ArrayList<>();
        private final @NonNull Outer<@NonNull ? extends Value> allValuePermutations;

        /**
         * This object contains s list containing all bids in the space. This is an
         * ImmutableList so it can contain all bids without pre-computing them.
         * 
         * @param domain the {@link Domain}
         * 
         */
        public AllBidsList(@NonNull Domain domain) {
                if (domain == null)
                        throw new IllegalArgumentException("domain=null");
                issues.addAll(domain.getIssuesValues().keySet());

                //#PY values = [domain.getValues(issue) for issue in issues]
                final @NonNull List<@NonNull ImmutableList<@NonNull Value>> values = issues
                                .stream().map(issue -> 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);

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

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

}