source: domaineditor/src/main/java/geniusweb/domaineditor/model/BidModel.java@ 52

package geniusweb.domaineditor.model;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.logging.Level;

import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.DiscreteValue;
import geniusweb.issuevalue.NumberValue;
import geniusweb.issuevalue.Value;
import tudelft.utilities.listener.DefaultListenable;
import tudelft.utilities.logging.Reporter;
import tudelft.utilities.mvc.model.BasicModel;
import tudelft.utilities.mvc.model.DefaultSelectionModel;
import tudelft.utilities.mvc.model.ListModel;
import tudelft.utilities.mvc.model.MapFromKeys;
import tudelft.utilities.mvc.model.MapModel;
import tudelft.utilities.mvc.model.SelectionModel;
import tudelft.utilities.mvc.model.StringModel;
import tudelft.utilities.mvc.model.TypedModel;
import tudelft.utilities.mvc.model.events.Added;
import tudelft.utilities.mvc.model.events.Changed;
import tudelft.utilities.mvc.model.events.Event;
import tudelft.utilities.mvc.model.events.Removed;

/**
 * contains modifyable {@link Bid} with values for all issues in the original
 * domain. Automatically adapts to changes in the {@link DomainModel}.
 * 
 * BidModel implements MapModel. However add and delete operations are not
 * allowed. That's because we do not want to modify the domain from here.
 * 
 * <br>
 * FIXME this implementation probably can be done much cleaner with
 * {@link MapFromKeys}
 *
 */
public class BidModel extends DefaultListenable<Event> implements
                MapModel<StringModel, SelectionModel<BasicModel>>, TypedModel<Bid> {
        private final MapModel<StringModel, ValueSetModel> issuevalues;
        private final Map<StringModel, SelectionModel<BasicModel>> selections = new HashMap<>();
        private final Reporter log;

        /**
         * 
         * @param issuevalues the map with issue values from
         *                    {@link DomainModel#getIssues()}
         */
        public BidModel(MapModel<StringModel, ValueSetModel> issuevalues,
                        Reporter log) {
                if (log == null || issuevalues == null)
                        throw new NullPointerException();
                this.issuevalues = issuevalues;
                this.log = log;
                ListModel<StringModel> keys = issuevalues.getKeys();
                for (int n = 0; n < keys.getSize(); n++) {
                        StringModel key = keys.get(n);
                        add(key, issuevalues.getValue(key).getList());
                }
                issuevalues.addListener((e) -> handleChange(e));

                // user's changes to the issuevalues are inconsequential
        }

        private void add(StringModel key, ListModel value) {
                selections.put(key, new DefaultSelectionModel(value));
        }

        /**
         * Domain change occured. Handle it.
         */
        private void handleChange(Event e) {
                // we only handle add/remove of issues. If a value is removed,
                // this should automatically reflect into the selectionmodel.
                if (!(e instanceof Changed)) {
                        System.out.println("Unexpected event " + e);
                        return;
                }
                e = e.getChildEvent();
                if (e instanceof Removed) {
                        // an issue was removed.
                        selections.remove(e.getSource());
                } else if (e instanceof Added) {
                        StringModel issuemodel = (StringModel) e.getSource();
                        add(issuemodel, issuevalues.getValue(issuemodel).getList());
                } else
                        System.out.println("Ignored event " + e);
                notifyListeners(e);
        }

        @Override
        public SelectionModel getValue(StringModel key) {
                return selections.get(key);
        }

        @Override
        public void put(StringModel key, SelectionModel val) {
                throw new UnsupportedOperationException();
        }

        @Override
        public void remove(StringModel key) {
                throw new UnsupportedOperationException();
        }

        @Override
        public ListModel<StringModel> getKeys() {
                return issuevalues.getKeys();
        }

        @Override
        public int getMinimumSize() {
                return 1;
        }

        @Override
        public String getColumnName(int n) {
                return n == 0 ? "issue" : "value";
        }

        @Override
        public Bid getCurrentValue() throws IllegalStateException {
                Map<String, Value> selectionmap = new HashMap<>();
                for (Entry<StringModel, SelectionModel<BasicModel>> entry : selections
                                .entrySet()) {
                        Value val = getVal(entry);
                        // ignore non-set values
                        if (val != null)
                                selectionmap.put(entry.getKey().getValue(), val);
                }
                return new Bid(selectionmap);
        }

        @Override
        public void setCurrentValue(Bid bid) throws IllegalArgumentException {
                ListModel<StringModel> issues = issuevalues.getKeys();
                for (int n = 0; n < issues.getSize(); n++) {
                        StringModel issuemodel = issues.get(n);
                        String issue = issuemodel.getValue();
                        Value val = bid.getValue(issue);
                        if (val == null) {
                                log.log(Level.WARNING,
                                                "Bid does not contain value for the issue " + issue);
                                continue;
                        }
                        ValueSetModel values = issuevalues.getValue(issues.get(n));
                        // now find & select the current model containing val
                        boolean isSet = false;
                        for (int v = 0; v < values.getList().getSize(); v++) {
                                BasicModel valuem = values.getList().get(v);
                                if (valuem.getValue().equals(val.getValue())) {
                                        selections.get(issuemodel).setSelection(valuem);
                                        isSet = true;
                                }
                        }
                        if (!isSet)
                                log.log(Level.WARNING,
                                                "Ignoring unknown value " + val + " in bid " + bid);
                }
        }

        /**
         * 
         * @param entry the key-value entry that was selected.
         * @return the selected value, or null if nothing is selected.
         */
        private Value getVal(Entry<StringModel, SelectionModel<BasicModel>> entry) {
                BasicModel sel = entry.getValue().getSelection();
                if (sel == null)
                        return null;
                Object val = sel.getValue();
                if (val instanceof String)
                        return new DiscreteValue((String) val);
                if (val instanceof BigDecimal)
                        return new NumberValue((BigDecimal) val);
                throw new IllegalStateException(
                                "Value " + val + " is not string or number");

        }

        @Override
        public SelectionModel<BasicModel> create(StringModel key) {
                throw new UnsupportedOperationException();
        }

}