source: references/src/main/java/geniusweb/references/Parameters.java@ 52

package geniusweb.references;

import java.util.HashMap;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;

/**
 * init parameters for a party. Object must be either a HashMap, List, String or
 * Number. Other objects may not deserialize properly. We never use blanket
 * Object deserializers (enableDefaultTyping) because of security reasons.
 *
 */
public class Parameters {

        @JsonValue
        private final HashMap<String, Object> params = new HashMap<>();

        public Parameters() {
        }

        @JsonCreator
        public Parameters(HashMap<String, Object> vals) {
                params.putAll(vals);
        }

        /**
         * 
         * @param key the key to get the value for.
         * @return the raw value
         */
        public Object get(String key) {
                return params.get(key);
        }

        /**
         * 
         * @return true iff params is empty
         */
        public boolean isEmpty() {
                return params.isEmpty();
        }

        /**
         * 
         * @param key the key to be checked
         * @return true iff params contains the given key
         */
        public boolean containsKey(String key) {
                return params.containsKey(key);
        }

        /**
         * 
         * @param key the key. Key may already in params.
         * @param val the new value for the key
         * @return new Parameters , which is copy of this but with key-value pair
         *         added/overridden
         */
        public Parameters with(String key, Object val) {
                HashMap<String, Object> newparams = new HashMap<String, Object>(params);
                newparams.put(key, val);
                return new Parameters(newparams);
        }

        /**
         * Getter with type-check
         * 
         * @param <T>       the expected type
         * @param paramname the parameter name that must be in the map
         * @param classType the expected value type for this parameter
         * @return object of requested type.
         * @throws IllegalArgumentException if the object is not available.
         */
        @SuppressWarnings("unchecked")
        public <T> T get(String paramname, Class<T> classType) {
                if (!params.containsKey(paramname)
                                || !(classType.isInstance(params.get(paramname))))
                        throw new IllegalArgumentException(" Missing a parameter "
                                        + paramname + " with a " + classType.getName() + " value");
                return (T) params.get(paramname);
        }

        /**
         * 
         * @param parameters the parameters to be added/overridden
         * @return new Parameters, with new parameters ADDED to existing. The new
         *         parameters override existing ones.
         */
        public Parameters with(Parameters parameters) {
                HashMap<String, Object> newparams = new HashMap<String, Object>(params);
                newparams.putAll(parameters.params);
                return new Parameters(newparams);
        }

        /**
         * 
         * @param name       the parameter name
         * @param defaultval the default value to return if parameter is not
         *                   available or not inside the given range. Can be null
         * @param min        the minimum value, or null if not applicable
         * @param max        the maximum value, or null if not applicable
         * @return the double value contained inside the parameter with the given
         *         name, or defaultval if the parameter does not exist, does not
         *         contain a double, or is outside [min, max].
         */
        public Double getDouble(String name, Double defaultval, Double min,
                        Double max) {
                if (!params.containsKey(name) || !(params.get(name) instanceof Number))
                        return defaultval;
                Double val = ((Number) params.get(name)).doubleValue();
                if (min != null && val < min)
                        return defaultval;
                if (max != null && val > max)
                        return defaultval;
                return val;
        }

        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result + ((params == null) ? 0 : params.hashCode());
                return result;
        }

        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (obj == null)
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                Parameters other = (Parameters) obj;
                if (params == null) {
                        if (other.params != null)
                                return false;
                } else if (!params.equals(other.params))
                        return false;
                return true;
        }

        @Override
        public String toString() {
                return params.toString();
        }

}