DefaultTopologyComponent.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;

import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Random;
import java.util.Set;

import de.tud.kom.p2psim.api.common.HostProperties;
import de.tud.kom.p2psim.api.common.Position;
import de.tud.kom.p2psim.api.common.SimHost;
import de.tud.kom.p2psim.api.topology.Topology;
import de.tud.kom.p2psim.api.topology.TopologyComponent;
import de.tud.kom.p2psim.api.topology.movement.MovementListener;
import de.tud.kom.p2psim.api.topology.movement.MovementSupported;
import de.tud.kom.p2psim.api.topology.movement.PositionListener;
import de.tud.kom.p2psim.api.topology.placement.PlacementModel;
import de.tud.kom.p2psim.impl.simengine.Simulator;
import de.tud.kom.p2psim.impl.topology.movement.modular.attraction.AttractionPoint;
import de.tudarmstadt.maki.simonstrator.api.Randoms;
import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.LocationListener;
import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.LocationRequest;
import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.LocationSensor;
import de.tudarmstadt.maki.simonstrator.api.operation.Operations;
import de.tudarmstadt.maki.simonstrator.api.operation.PeriodicOperation;

/**
 * Default implementation of a {@link TopologyComponent}.
 * 
 * @author Bjoern Richerzhagen
 * @version 1.0, 29.02.2012
 */
public class DefaultTopologyComponent implements TopologyComponent,
		LocationSensor {
	protected static Random rnd = Randoms.getRandom(AttractionPoint.class);

	private SimHost host;

	private PositionVector position;

	private Topology topology;

	private Set<PositionListener> positionListener = new LinkedHashSet<PositionListener>();

	private Set<MovementListener> movementListeners = new LinkedHashSet<>();

	/**
	 * This reference is nulled after placement, as the process is only done
	 * once.
	 */
	private PlacementModel placement;

	public DefaultTopologyComponent(SimHost host, Topology topology,
			PlacementModel placement) {
		this.topology = topology;
		this.placement = placement;
		this.host = host;
		// TODO maybe we need to do this in the initialize-method
		placement.addComponent(this);
	}

	@Override
	public void initialize() {
		position = placement.place(this);
		placement = null;
		topology.addComponent(this);
	}

	@Override
	public void shutdown() {
		topology = null;
		positionListener.clear();
		movementListeners.clear();
		host = null;
	}

	@Override
	public SimHost getHost() {
		return host;
	}

	@Override
	public void positionChanged() {
		for (PositionListener listener : positionListener) {
			if (listener.getPosition().getDistance(position) < listener
					.getRadius()) {
				listener.reachedPosition();
			}
		}
	}

	@Override
	public void afterComponentMoved(MovementSupported comp) {
		for (MovementListener moveListener : movementListeners) {
			moveListener.afterComponentMoved(this);
		}
	}

	@Override
	public void afterComponentsMoved() {
		for (MovementListener moveListener : movementListeners) {
			moveListener.afterComponentsMoved();
		}
	}

	@Override
	public boolean movementActive() {
		/*
		 * Needed? Maybe redesign the API
		 */
		return true;
	}

	@Override
	public PositionVector getRealPosition() {
		return position;
	}

	@Override
	public Position getPosition(PositionAccuracy accuracy) {
		/*
		 * TODO :)
		 */
		return position;
	}

	@Override
	public Topology getTopology() {
		return topology;
	}

	@Override
	public void addPositionListener(PositionListener listener) {
		positionListener.add(listener);
	}

	@Override
	public void removePositionListener(PositionListener listener) {
		positionListener.remove(listener);
	}

	@Override
	public void addMovementListener(MovementListener listener) {
		movementListeners.add(listener);
	}

	@Override
	public void removeMovementListener(MovementListener listener) {
		movementListeners.remove(listener);
	}

	@Override
	public double getMinMovementSpeed() {
		HostProperties properties = getHost().getProperties();

		return properties.getMinMovementSpeed();
	}

	@Override
	public double getMaxMovementSpeed() {
		HostProperties properties = getHost().getProperties();
		return properties.getMaxMovementSpeed();
	}

	@Override
	public double getMovementSpeed() {
		double min_speed;
		double max_speed;

		min_speed = getMinMovementSpeed();
		max_speed = getMaxMovementSpeed();

		double value = rnd.nextDouble();
		double speed = (value * (max_speed - min_speed)) + min_speed;
		return speed;
	}

	@Override
	public Location getLastLocation() {
		/*
		 * As we want to mimic real world behavior, the current position
		 * snapshot is cloned to prevent information propagation due to Java.
		 */
		return position.clone();
	}

	@Override
	public void requestLocationUpdates(LocationRequest request,
			LocationListener listener) {
		LocationRequestImpl req = (LocationRequestImpl) request;
		openRequests.put(listener, req);
		req.immunizeAndStart(listener);
	}

	@Override
	public void removeLocationUpdates(LocationListener listener) {
		LocationRequestImpl impl = openRequests.remove(listener);
		impl.cancel();
	}

	@Override
	public LocationRequest getLocationRequest() {
		return new LocationRequestImpl();
	}

	private Map<LocationListener, LocationRequestImpl> openRequests = new LinkedHashMap<LocationListener, LocationRequestImpl>();

	private class LocationRequestImpl implements LocationRequest {

		private boolean immune = false;

		private long interval = 1 * Simulator.MINUTE_UNIT;

		private int priority = LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY;

		LocationListener listener;

		private PeriodicOperation<LocationSensor, Object> op;

		public LocationRequestImpl() {
			// nothing to do
		}

		protected void cancel() {
			op.stop();
			op = null;
			listener = null;
		}

		protected void immunizeAndStart(LocationListener listener) {
			immune = true;
			this.listener = listener;
			assert interval > 0;
			op = new PeriodicOperation<LocationSensor, Object>(
					DefaultTopologyComponent.this,
					Operations.getEmptyCallback(), interval) {
				@Override
				protected void executeOnce() {
					LocationRequestImpl.this.listener
							.onLocationChanged(getLastLocation());
				}

				@Override
				public Object getResult() {
					return null;
				}
			};
			/*
			 * Start somewhere within the interval, and from then on, update
			 * periodically.
			 */
			op.scheduleWithDelay((long) Randoms
					.getRandom(LocationRequest.class).nextDouble() * interval);
		}

		@Override
		public void setInterval(long interval) {
			if (!immune) {
				this.interval = interval;
			}
		}

		@Override
		public void setPriority(int priority) {
			if (!immune) {
				this.priority = priority;
			}
		}

	}

}