praktikum-holons/src/algorithms/geneticAlgorithm/holegGA/Components/HolegIndividual.java

package algorithms.geneticAlgorithm.holegGA.Components;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

import classes.AbstractCpsObject;
import classes.CpsNode;
import algorithms.geneticAlgorithm.Components.GAIndividual;
import algorithms.geneticAlgorithm.holegGA.GAEdge;

public class HolegIndividual extends GAIndividual {
	
	private ArrayList<GAEdge> holonEdges;
	public ArrayList<Integer> indexes;
	public ArrayList<Integer> originIndexes;
	public ArrayList<HolegIndividual> parents;
	public HashMap<Integer, AbstractCpsObject> indexToObjectMap;
	private HashMap<AbstractCpsObject, Integer> objectToIndexMap;
	public boolean drawn;
	public String id;
	public String log;
	public int gen;
	public int pos;
	private int lastIndex;
	
	public HolegIndividual(ArrayList<AbstractCpsObject> originObjects){
		holonEdges = new ArrayList<GAEdge>();
		indexes = new ArrayList<Integer>();
		originIndexes = new ArrayList<Integer>();
		parents = new ArrayList<HolegIndividual>();
		indexToObjectMap = new HashMap<Integer, AbstractCpsObject>();
		objectToIndexMap = new HashMap<AbstractCpsObject, Integer>();
		lastIndex = 0;
		log = "Individual Log";
		drawn = false;
		
		for(AbstractCpsObject abs : originObjects){
			AbstractCpsObject newObj = abs.makeCopy();
			newObj.setPosition(abs.getPosition());
			addObject(newObj);
			originIndexes.add(objectToIndexMap.get(newObj));
		}
	}
	
	public HolegIndividual(HolegIndividual indi){
		holonEdges = new ArrayList<GAEdge>();
		holonEdges.addAll(indi.getEdges());
		indexes = new ArrayList<Integer>();
		indexes.addAll(indi.getIndexes());
		originIndexes = new ArrayList<Integer>();
		originIndexes.addAll(indi.originIndexes);
		parents = new ArrayList<HolegIndividual>();
		
		indexToObjectMap = new HashMap<Integer, AbstractCpsObject>();
		objectToIndexMap = new HashMap<AbstractCpsObject, Integer>();
		Set<Integer> keys = indi.indexToObjectMap.keySet();
		for(Integer i : keys){
			indexToObjectMap.put(i, indi.indexToObjectMap.get(i));
			objectToIndexMap.put(indi.indexToObjectMap.get(i), i);
		}

		lastIndex = indi.lastIndex;
		log = "Individual Log";
		drawn = false;
		
	}
	
	public ArrayList<HolegIndividual> getParents(){
		return parents;
	}
	
	public void setParents(ArrayList<HolegIndividual> parents){
		this.parents = parents;
		for(int i = 0; i < parents.size(); i++){
			addLogEntry("Parent" + i + ": " + parents.get(i).getId());
		}
	}
	
	public void setId(int Gen, int pos){
		if(Gen > 0){
			id = "Generation_" + Gen + " Rank_" + pos;
		}else{
			id = "Generation_Original";
		}
	}
	
	public String getId(){
		return id;
	}
	
	public ArrayList<AbstractCpsObject> getObjects(){
		ArrayList<AbstractCpsObject> objects = new ArrayList<AbstractCpsObject>();
		for(Integer i : indexes){
			objects.add(indexToObjectMap.get(i));
		}
		return objects;
	}
	
	public ArrayList<AbstractCpsObject> getOriginObjects(){
		ArrayList<AbstractCpsObject> originObjects = new ArrayList<AbstractCpsObject>();
		for(Integer i : originIndexes){
			originObjects.add(indexToObjectMap.get(i));
		}
		return originObjects;
	}
	
	public AbstractCpsObject getObjectWithIndex(int index){
		return indexToObjectMap.get(index);
	}
	
	public AbstractCpsObject getObjectAt(int position){
		return indexToObjectMap.get(indexes.get(position));
	}
	
	public ArrayList<Integer> getIndexes(){
		return indexes;
	}
	
	public ArrayList<Integer> getNonOriginIndexes(){
		if(indexes.size() > originIndexes.size()){
			return new ArrayList<Integer>(indexes.subList(originIndexes.size(), indexes.size()));
		}else{
			return new ArrayList<Integer>();
		}
	}
	
	public ArrayList<GAEdge> getEdges(){
		return holonEdges;
	}
	
	public void addObject(AbstractCpsObject obj){
		addObjectWithIdx(obj, lastIndex);
		lastIndex++;
	}
	
	public void addObjectWithIdx(AbstractCpsObject obj, int index){
		if(!indexToObjectMap.containsKey(index)){
			addIndex(index);
			indexToObjectMap.put(index, obj);
			objectToIndexMap.put(obj, index);
		}else{
			objectToIndexMap.remove(indexToObjectMap.get(index));
			indexToObjectMap.put(index, obj);
			objectToIndexMap.put(obj, index);
		}
		//indexToObjectMap.put(index, obj);
	}
	
	public void removeObject(int index){
		indexToObjectMap.remove(index);
		indexes.remove((Object)index);
	}
	
	public void addIndex(int index){
		for(int i = 0; i < indexes.size(); i++){
			if(index < indexes.get(i)){
				indexes.add(i, index);
				return;
			}
		}
		indexes.add(index);
		return;
	}
	/*
	 * posA and posB are the indexes of the Endpoints A and B in the list of Objects
	 */
	public void addEdge(int indexA, int indexB){
		if(!edgeExists(indexA, indexB)){
			
			if(!indexToObjectMap.containsKey(indexA)){
				CpsNode newObjA = new CpsNode("Node");
				addObjectWithIdx(newObjA, indexA);
			}
			if(!indexToObjectMap.containsKey(indexB)){
				CpsNode newObjB = new CpsNode("Node");
				addObjectWithIdx(newObjB, indexB);
			}
			holonEdges.add(new GAEdge(indexA, indexB, indexToObjectMap.get(indexA), indexToObjectMap.get(indexB)));
		
		}else{
			addLogEntry("double Edge: " + indexToObjectMap.get(indexA).getId() + " to " 
					+ indexToObjectMap.get(indexB).getId());
		}

	}
	
	public boolean edgeExists(int indexA, int indexB){
		for(GAEdge e : holonEdges){
			if((e.aPos == indexA && e.bPos == indexB) || (e.bPos == indexA && e.aPos == indexB)){
				return true;
			}
		}
		return false;
	}
	
	public void addLogEntry(String entry){
		log += "\n" + entry;
	}
	
	public int getAvailableIndex(){
		for(int i = 0; i <= indexes.size(); i++){
			if(!indexes.contains(i)){
				return i;
			}
		}
		return -1;
	}

}