AbstractAttractionBasedAssignmentStrategy.java

/*
 * Copyright (c) 2005-2010 KOM – Multimedia Communications Lab
 *
 * This file is part of PeerfactSim.KOM.
 * 
 * PeerfactSim.KOM 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
 * any later version.
 * 
 * PeerfactSim.KOM 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.
 * 
 * You should have received a copy of the GNU General Public License
 * along with PeerfactSim.KOM.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

package de.tud.kom.p2psim.impl.topology.movement.modularosm.transition;

import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Random;

import de.tud.kom.p2psim.api.topology.movement.SimLocationActuator;
import de.tud.kom.p2psim.impl.topology.movement.modularosm.attraction.IAttractionGenerator;
import de.tudarmstadt.maki.simonstrator.api.Randoms;
import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.AttractionPoint;

/**
 * Abstract base class for Transition Strategies ({@link IAttractionAssigmentStrategy}s) using {@link AttractionPoint}s.
 * 
 * @author Julian Zobel
 * @version 1.0, 23.01.2019
 */
public abstract class AbstractAttractionBasedAssignmentStrategy implements IAttractionAssigmentStrategy {

	protected Random rnd = Randoms.getRandom(AbstractAttractionBasedAssignmentStrategy.class);
		
	protected Map<SimLocationActuator, AttractionPoint> assignments = new LinkedHashMap<>();
	
	protected Map<SimLocationActuator, AttractionPoint> lastAssignments = new LinkedHashMap<>();
	
	private List<AttractionAssignmentListener> listeners = new LinkedList<>();
	
	protected long defaultPauseTimeMin = 0;	
	protected long defaultPauseTimeMax = 0;
	
	protected final static int EVENT_PAUSE_ENDED = 1;
	
	@Override
	public AttractionPoint getAssignment(SimLocationActuator comp) {
		return assignments.get(comp);
	}
	
	@Override
	public void addAttractionAssignmentListener(
			AttractionAssignmentListener listener) {
		listeners.add(listener);
	}
	
	@Override
	public void removeAttractionAssignmentListener(
			AttractionAssignmentListener listener) {
		listeners.remove(listener);
	}

	/**
	 * Notify all listeners of an updated attraction point assignment for the given component
	 * 
	 * @param comp
	 * @param attractionPoint
	 */
	protected void notifyListenersOfAssignmentUpdate(SimLocationActuator comp,
			AttractionPoint attractionPoint) {
		listeners.forEach(listener -> listener.updatedAttractionAssignment(comp, attractionPoint));
	}
	
	@Override
	public void updateTargetAttractionPoint(SimLocationActuator comp,
			AttractionPoint attractionPoint) {
		if(assignments.containsKey(comp)) {
			this.lastAssignments.put(comp, this.assignments.remove(comp));
		}
		this.assignments.put(comp, attractionPoint);
		notifyListenersOfAssignmentUpdate(comp, attractionPoint);	
	}
	
	private long getRandomUniformDistributionPauseTime(AttractionPoint attractionPoint) {
		
		// if attraction point has own pause time use it, otherwise use default values
		if(attractionPoint.hasPauseTime()) {
			return (long) (rnd.nextDouble() * (attractionPoint.getPauseTimeMax() - attractionPoint.getPauseTimeMin())) + attractionPoint.getPauseTimeMin();
		}
		else {
			return (long) (rnd.nextDouble() * (defaultPauseTimeMax - defaultPauseTimeMin)) + defaultPauseTimeMin;
		}		
	}
	
	protected long getPauseTime(AttractionPoint attractionPoint) {
		return getRandomUniformDistributionPauseTime(attractionPoint);
	}	
	
	protected AttractionPoint getNewAttractionPointAssignment(SimLocationActuator component) {		
		double score = rnd.nextDouble();		
		List<AttractionPoint> candidates = new LinkedList<>();
		for (AttractionPoint ap : IAttractionGenerator.attractionPoints) {
			
			if(ap == null) {
				continue;
			}
			
			if (ap.getWeight() >= score) {
				if(lastAssignments.get(component) == null || !ap.equals(lastAssignments.get(component))) {
					candidates.add(ap);
				}				
			}
		}
		
		if (candidates.isEmpty()) {
			candidates.addAll(IAttractionGenerator.attractionPoints);
		}
		
		AttractionPoint assignment = candidates.get(rnd.nextInt(candidates.size()));		
		return assignment;		
	}  
}