idealnode.java

DTNSim2 is a simulator for Delay-Tolerant Networks (DTNs) written in Java. It is based on Sushant Ja

package implementations;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;

import simulator.Contact;
import simulator.Message;
import simulator.Node;
import simulator.Stats;

import util.CommandStatus;
import util.Verbose;

public class IdealNode extends Node
{
	private int msgDataLength = 10;

	private ArrayList<Message> buffer = new ArrayList<Message>();

	private HashSet<Contact> idleContacts = new HashSet<Contact>();

	private ArrayList<Message> messagesSent = new ArrayList<Message>();

	public IdealNode()
	{
		super();
	}

	public IdealNode(IdealNode org)
	{
		super(org);

		msgDataLength = org.msgDataLength;
	}

	public boolean hasMessage(Message msg)
	{
		return buffer.contains(msg) || receivedMessage(msg);
	}

	public boolean willHaveMessage(Message msg)
	{
		return messagesSent.contains(msg);
	}

	public void addSentMessage(Message msg)
	{
		messagesSent.add(msg);
	}

	public void removeSentMessage(Message msg)
	{
		messagesSent.remove(msg);
	}

	protected boolean acceptMessage(Message msg, Contact contact, int size)
	{
		// TODO - maybe return false?
		if (buffer.contains(msg))
			return true;

		buffer.add(msg);

		checkIdleContacts();

		return true;
	}

	public boolean sendNewMessage(int dataLength, Node destNode)
	{
		Message msg = new Message(network.getNextMessageId(), network.getCurrentTime(), this, destNode, dataLength);

		statMsgEntry.setup(msg, network.getCurrentTime(), Stats.MSG_CREATED);
		network.stats().notify(statMsgEntry);

		buffer.add(msg);

		checkIdleContacts();

		return true;
	}

	public CommandStatus parseCommandPart(ArrayList<String> part, String path)
	{
		String param = part.get(0);
		CommandStatus ok = new CommandStatus(CommandStatus.COMMAND_OK);

		if (part.size() != 2)
			return null;

		if (param.equals("send"))
		{
			sendNewMessage(msgDataLength, network.getNode(part.get(1)));
			return ok;
		}

		int val;

		try
		{
			if (param.equals("msg_size"))
			{
				val = Integer.parseInt(part.get(1));

				if (val < 1)
				{
					return new CommandStatus("Message Size can not be < 1!");
				}

				msgDataLength = val;

				return ok;
			}
		}
		catch (NumberFormatException e)
		{
			return new CommandStatus("Error parsing value of parameter '" + param + "': " + e);
		}

		return null;
	}

	public boolean sendNext(Contact contact)
	{
		Iterator<Message> i = buffer.iterator();

		assert contact.isUp() && contact.isIdle();

		while (i.hasNext())
		{
			Message m = i.next();

			// We want to send message m only if other node doesn't have it and
			// it is not already transmitted (byt this or any other contact)
			if (!((IdealNode) contact.getDest()).hasMessage(m) && !((IdealNode) contact.getDest()).willHaveMessage(m))
			{
				if (contact.sendMessage(m))
				{
					((IdealNode) contact.getDest()).addSentMessage(m);

					return true;
				}
			}
		}

		if (network.vShouldLog(Verbose.DEBUG4))
			network.vprint("NOP - Nothing left to send in " + this);

		return false;
	}

	public void contactIdle(Contact contact)
	{
		super.contactIdle(contact);

		if (!sendNext(contact))
			idleContacts.add(contact);
	}

	public void checkSend(Message msg, Contact contact, int size)
	{
		if (msg.getLength() > size)
		{
			((IdealNode) contact.getDest()).removeSentMessage(msg);
		}
	}

	public void messageSent(Message msg, Contact contact, int size)
	{
		checkSend(msg, contact, size);
	}

	public void messageDelivered(Message msg, Contact contact, int size)
	{
		checkSend(msg, contact, size);
	}

	public void contactDown(Contact contact)
	{
		super.contactDown(contact);

		idleContacts.remove(contact);
	}

	private void checkIdleContacts()
	{
		Iterator<Contact> it = idleContacts.iterator();

		while (it.hasNext())
		{
			Contact c = it.next();

			if (sendNext(c))
				it.remove();
		}
	}
}