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

package geniusweb.domaineditor.model;

import java.io.File;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import geniusweb.domaineditor.ProfileEditor;
import geniusweb.issuevalue.Domain;
import geniusweb.issuevalue.ValueSet;
import tudelft.utilities.listener.DefaultListenable;
import tudelft.utilities.logging.Reporter;
import tudelft.utilities.mvc.model.DefaultMapModel;
import tudelft.utilities.mvc.model.MapModel;
import tudelft.utilities.mvc.model.Model;
import tudelft.utilities.mvc.model.StringModel;
import tudelft.utilities.mvc.model.TypedModel;
import tudelft.utilities.mvc.model.events.Changed;
import tudelft.utilities.mvc.model.events.Event;

/**
 * Contains a mutable {@link Domain}. Listeners are notified about any changes
 * and can act accordingly. Notifications contain WHAT changed: the name of the
 * issue, or "" if the NAME changed of the domain. For internal use in the
 * {@link ProfileEditor} and related
 *
 */
public class DomainModel extends DefaultListenable<Event>
                implements TypedModel<Domain> {
        private static final ObjectMapper jackson = new ObjectMapper();
        private final StringModel domainname;
        private final MapModel<StringModel, ValueSetModel> issuesmodel;
        private final Reporter log;

        public DomainModel(StringModel name,
                        MapModel<StringModel, ValueSetModel> issues, Reporter log) {
                if (issues.getMinimumSize() != 1)
                        throw new IllegalArgumentException(
                                        "domain must have minimum size of at least 1 issue");
                this.domainname = name;
                this.issuesmodel = issues;
                this.log = log;
                DomainModel that = this;
                domainname.addListener((e) -> notifyListeners(new Changed(this, e)));
                // dont wrap issuemodel events into another Changed, it's already in one
                issuesmodel.addListener((e) -> notifyListeners(e));
        }

        public DomainModel(Reporter log) {
                this(new SimpleStringModel("domainname", log),
                                new DefaultMapModel<StringModel, ValueSetModel>(
                                                Collections.singletonMap(new StringModel("issue", log),
                                                                new DiscreteValueSetModel(log)),
                                                log) {
                                        @Override
                                        public int getMinimumSize() {
                                                return 1;
                                        }

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

                                        @Override
                                        public ValueSetModel create(StringModel key) {
                                                throw new UnsupportedOperationException();
                                        }

                                }, log);
        }

        /**
         * Create the domain from a file.
         * 
         * @param file the file containing the domain
         * @throws Exception if problem with the file
         */
        public static DomainModel create(File file, Reporter log)
                        throws JsonParseException, JsonMappingException, IOException {
                Domain domain = jackson.readValue(file, Domain.class);
                // FIXME
                return new DomainModel(new StringModel(domain.getName(), log), null,
                                log);
        }

        /**
         * 
         * @return the model containing the domain name.
         */
        public StringModel getName() {
                return domainname;
        }

        /**
         * 
         * @return the model containing the issues-values map
         */
        public MapModel<StringModel, ValueSetModel> getIssues() {
                return issuesmodel;
        }

        /**
         * 
         * @return the {@link Domain} contained in this model.
         */
        @Override
        public Domain getCurrentValue() throws IllegalStateException {
                Map<String, ValueSet> issues = new HashMap<>();
                for (int n = 0; n < issuesmodel.getKeys().getSize(); n++) {
                        StringModel key = issuesmodel.getKeys().get(n);
                        issues.put(key.getValue(),
                                        issuesmodel.getValue(key).getCurrentValue());
                }

                return new Domain(domainname.getValue(), issues);
        }

        /**
         * Set new {@link Domain}
         * 
         * @param obj the new {@link Domain}. This assumes the old domain can be
         *            completely deleted and replaced with this new one. New
         *            {@link Model}s are created where needed.
         */
        @Override
        public void setCurrentValue(Domain dom) throws IllegalArgumentException {
                domainname.setValue(dom.getName());

                // collect old issues
                List<StringModel> oldissues = new LinkedList<>();
                for (int n = 0; n < issuesmodel.getKeys().getSize(); n++)
                        oldissues.add(issuesmodel.getKeys().get(n));

                // add new ones first (minimum size)
                for (String iss : dom.getIssues()) {
                        ValueSetModel valsetmodel = ValueSetModelType.createModel(
                                        ValueSetModelType.fromModel(dom.getValues(iss)), log);
                        valsetmodel.setCurrentValue(dom.getValues(iss));
                        issuesmodel.put(new StringModel(iss, log), valsetmodel);
                }
                // remove the old issues
                for (StringModel iss : oldissues)
                        issuesmodel.remove(iss);
        }
}