VariableBindingsIterator.java

/*
 * JABM - Java Agent-Based Modeling Toolkit
 * Copyright (C) 2013 Steve Phelps
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 3 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 */
package net.sourceforge.jabm;

import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import net.sourceforge.jabm.util.UntypedDouble;
import net.sourceforge.jabm.util.UntypedLong;
import net.sourceforge.jabm.util.UntypedNumber;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.BeanFactory;

class VariableBindingsIterator implements Iterator<Map<String,String>> {

	protected Map<String, VariableRange> variableRanges;
	
	protected ArrayList<String> variables;
	
	protected Bindings bindings;
	
	protected int currentVariableIndex;
	
	protected BeanFactory beanFactory;

	protected boolean hasNext;
	
	public static final String RANGE_REGEXP =
		"([0-9\\.]+)\\:([0-9\\.]+)\\:([0-9\\.]+)";
	
	static Pattern rangePattern = Pattern.compile(RANGE_REGEXP);
	
	static Logger logger = Logger.getLogger(VariableBindingsIterator.class);
	
	
	public VariableBindingsIterator(String varFile, 
										BeanFactory beanFactory) {
		try {
			this.beanFactory = beanFactory;
			parseVarFile(varFile);
			bindings = initialBindings();
			currentVariableIndex = variables.size() - 1;
			hasNext = variables.size() > 0;
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
	
	public Bindings initialBindings() {
		Bindings result = new Bindings();
		for(String variable : variables) {
			UntypedNumber initialValue = 
				variableRanges.get(variable).getMin();
			result.set(variable, initialValue);
		}
		return result;
	}
		
	@SuppressWarnings("rawtypes")
	public void parseVarFile(String varFile) throws IOException {
		Properties properties = new Properties();
		variableRanges = new HashMap<String, VariableRange>();
		properties.load(new FileInputStream(varFile));
		for(Object variable : properties.keySet()) {
			Class type = getType(variable.toString());
			VariableRange range = 
				parseVariableRange(properties.get(variable).toString(), type);
			logger.debug("range = " + range);
			variableRanges.put(variable.toString(), range);
		}
		variables = new ArrayList<String>(variableRanges.keySet());
	}
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public Class getType(String beanProperty) {
		int dot = beanProperty.indexOf('.');
		String beanName = beanProperty.substring(0, dot);
		String attributeName = beanProperty.substring(dot+1);
		Class beanType = beanFactory.getType(beanName);
		String getterName = "get" + 
			Character.toUpperCase(attributeName.charAt(0)) + 
				attributeName.substring(1);
		try {
			Method method = beanType.getMethod(getterName, new Class[] {});
			Type returnType = method.getGenericReturnType();
			if (returnType instanceof Class) {
				Class result = (Class) returnType;
				return result;
			} else {
				throw new IllegalArgumentException(beanProperty);
			}
		} catch (NoSuchMethodException e) {
			throw new RuntimeException(e);
		}
	}
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public VariableRange parseVariableRange(String rangeSpecification,
											 Class type) {
		Matcher matcher = rangePattern.matcher(rangeSpecification);
		if (matcher.matches()) {
			VariableRange result = new VariableRange();
			String minStr = matcher.group(1);
			String incrStr = matcher.group(2);
			String maxStr = matcher.group(3);
			if (type.isAssignableFrom(int.class) || type.isAssignableFrom(long.class)) {
				result.setMin(new UntypedLong(Long.parseLong(minStr)));
				result.setIncrement(new UntypedLong(Long.parseLong(incrStr)));
				result.setMax(new UntypedLong(Long.parseLong(maxStr)));
			} else if (type.isAssignableFrom(double.class) || type.isAssignableFrom(float.class)) {
				result.setMin(new UntypedDouble(Double.parseDouble(minStr)));
				result.setIncrement(new UntypedDouble(Double.parseDouble(incrStr)));
				result.setMax(new UntypedDouble(Double.parseDouble(maxStr)));
			} else {
				throw new IllegalArgumentException(type.toString());
			}
			return result;
		}
		throw new IllegalArgumentException(
				"Could not parse range specification: " + 
					rangeSpecification);
	}
	
	@Override
	public boolean hasNext() {
		return hasNext;
	}

	@Override
	public Map<String, String> next() {

		Map<String, String> result = bindings.getStringBindings();

		logger.debug(variableName(currentVariableIndex) + " = "
				+ bindings.get(currentVariableIndex));

		if (lessThanMaximumValue(currentVariableIndex)) {
			increment(currentVariableIndex);
		} else {
			// Back
			while (currentVariableIndex >= 0
					&& !lessThanMaximumValue(currentVariableIndex)) {
				currentVariableIndex--;
			}
			if (currentVariableIndex < 0) {
				hasNext = false;
				return result;
			}
			increment(currentVariableIndex);
			for (int i = currentVariableIndex + 1; i < variables.size(); i++) {
				bindings.set(variableName(i), getMin(i));
			}
			currentVariableIndex = variables.size() - 1;
		}

		return result;
	}

	@Override
	public void remove() {
		throw new RuntimeException("Unsupported method");
	}
	
	public String variableName(int variableIndex) {
		return variables.get(variableIndex);
	}
	
	public void increment(int variableIndex) {
		bindings.increment(variableName(variableIndex));
	}
	
	public boolean lessThanMaximumValue(int variableIndex) {
		String variableName = variableName(variableIndex);
		double value = bindings.get(variableName).doubleValue();
		double max = variableRanges.get(variableName).getMax().doubleValue();
		return value < (max - 10E-9);
	}
	
	public UntypedNumber getMin(int variableIndex) {
		String variableName = variableName(variableIndex);
		return variableRanges.get(variableName).getMin();
	}

	class VariableRange {
		
		public UntypedNumber min;
		
		public UntypedNumber max;
		
		public UntypedNumber increment;

		public VariableRange(UntypedNumber min, UntypedNumber max, 
								UntypedNumber increment) {
			super();
			this.min = min;
			this.max = max;
			this.increment = increment;
		}
		
		public VariableRange() {
			super();
		}

		public UntypedNumber getMin() {
			return min;
		}

		public void setMin(UntypedNumber min) {
			this.min = min;
		}

		public UntypedNumber getMax() {
			return max;
		}

		public void setMax(UntypedNumber max) {
			this.max = max;
		}

		public UntypedNumber getIncrement() {
			return increment;
		}

		public void setIncrement(UntypedNumber increment) {
			this.increment = increment;
		}
		
		public String toString() {
			return min + ":" + increment + ":" + max;
		}
	}

	class Bindings {

		Map<String, UntypedNumber> variableMap;
		
		public Bindings() {
			variableMap = new HashMap<String, UntypedNumber>();
		}
		
		public void set(String variable, UntypedNumber value) {
			variableMap.put(variable, value);
		}
		
		public void increment(String variable) {
			UntypedNumber currentValue = variableMap.get(variable);
			UntypedNumber newValue = 
				currentValue.add(variableRanges.get(variable).getIncrement());
			set(variable, newValue);
		}
		
		public UntypedNumber getNextValue(String variable) {
			UntypedNumber currentValue = variableMap.get(variable);
			UntypedNumber newValue = 
				currentValue.add(variableRanges.get(variable).getIncrement());
			return newValue;
		}
		
		public UntypedNumber get(String variable) {
			return variableMap.get(variable);
		}
		
		public UntypedNumber get(int variableIndex) {
			String variableName = variables.get(variableIndex);
			return get(variableName);
		}
		
		public Set<String> getVariables() {
			return variableMap.keySet();
		}
		
		public Map<String, String> getStringBindings() {
			HashMap<String, String> result = new HashMap<String, String>();
			for(String variable : variableMap.keySet()) {
				result.put(variable, variableMap.get(variable).toString());
			}
			return result;
		}
	}
	
}