source: xssim/trunk/src/simulator/lists/slotList/TimeResOptIterator.java @ 104

package simulator.lists.slotList;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.joda.time.DateTime;

import schedframe.resources.ResourceProvider;
import schedframe.resources.ResourceStateDescription;
import schedframe.resources.units.Processors;
import schedframe.resources.units.ResourceUnit;
import schedframe.scheduling.TimeResourceAllocation;
import schedframe.scheduling.utils.ResourceParameterName;

/**
 * 
 * @author Marcin Krystek
 *
 */
public class TimeResOptIterator implements SlotsGanttIterator {

        protected SlotsGantt list;
        protected ArrayList<TimeResourceAllocation> newSlots;
        protected int currentPosition = 0;
        
        public void visit(SlotsGantt list) {
                this.list = list;
                this.newSlots = new ArrayList<TimeResourceAllocation>();
                int totalAmount = -1;
                String resName = null;
                ArrayList<Integer> cpuCnt = new ArrayList<Integer>(list.size());
                
                try {
                
                        for(int i = 0; i < this.list.size(); i++){
                                ResourceUnit unit = list.get(i).getAllocatedResource().
                                                                        getResourceUnit(ResourceParameterName.CPUCOUNT); 
                                cpuCnt.add(unit.getUsedAmount());
                                if(i == 0) {
                                        totalAmount = unit.getAmount();
                                        resName = unit.getResourceId();
                                }
                        }
                        
                        List<Integer> uniqeCpuCnt = getUniqeResourceValues(cpuCnt);
                        ArrayList<ArrayList<Integer>> ll = new ArrayList<ArrayList<Integer>>(uniqeCpuCnt.size());
                        for(int i = 0; i < uniqeCpuCnt.size(); i++){
                                ArrayList<Integer> slotIndexes = new ArrayList<Integer>();
                                int cnt = uniqeCpuCnt.get(i);
                                for(int j = 0; j < cpuCnt.size(); j++){
                                        if(cnt <= cpuCnt.get(j)){
                                                slotIndexes.add(j);
                                        }
                                }
                                ll.add(slotIndexes);
                        }
                        
                        for(int i = 0; i < ll.size(); i++){
                                ArrayList<Integer> l = ll.get(i);
                                
                                for(int j = 0; j < l.size(); j++){
                                        int compareRresult = 0;
                                        TimeResourceAllocation slot = list.get(l.get(j));
                                        DateTime startTime = slot.getStart();
                                        DateTime endTime = slot.getEnd();
                                        
                                        while(compareRresult == 0 && j < l.size() - 1){
                                                endTime = slot.getEnd();
                                                slot = list.get(l.get(++j));
                                                compareRresult = endTime.compareTo(slot.getStart());
                                        }
                                        
                                        if(compareRresult == 0)
                                                endTime = slot.getEnd();
                                        else
                                                j--;
                                        
                                        ResourceStateDescription rsd = new ResourceStateDescription((ResourceProvider)null);
                                        rsd.addResourceUnit(new Processors(resName, totalAmount, uniqeCpuCnt.get(i)));
                                        TimeResourceAllocation newSlot = new TimeResourceAllocation(rsd, startTime, endTime);
                                        
                                        this.newSlots.add(newSlot);
                                }
                        }
                } catch(NoSuchFieldException e){
                        e.printStackTrace();
                }
        }
        

        protected List<Integer> getUniqeResourceValues(List<Integer> list){
                ArrayList<Integer> localList = new ArrayList<Integer>(list.size());
                for(int i = 0; i < list.size(); i++){
                        localList.add(list.get(i));
                }
                Collections.sort(localList);
                ArrayList<Integer> ret = new ArrayList<Integer>();
                
                int prev = localList.get(0);
                if(prev != 0)
                        ret.add(prev);

                for(int i = 1; i < localList.size(); i++){
                        int current = localList.get(i);
                        if(prev != current){
                                prev = current;
                                if(current != 0) ret.add(current);
                        }
                }
                return ret;
        }
        
        public boolean hasNext() {
                return (currentPosition < newSlots.size());
        }

        public TimeResourceAllocation next() {
                return newSlots.get(currentPosition++);
        }

        public void remove() {
                throw new RuntimeException("Removing object by "+this.getClass() +" is not supported.");
        }
        
        public void reset(){
                currentPosition = 0;
        }
}