source: DCWoRMS/branches/coolemall/src/schedframe/resources/computing/description/ComputingResourceDescription.java @ 1282

package schedframe.resources.computing.description;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import schedframe.Parameters;
import schedframe.resources.ResourceTypeFactory;
import schedframe.resources.devices.Device;
import schedframe.resources.devices.DeviceFactory;
import schedframe.resources.devices.description.DeviceDescription;
import schedframe.resources.devices.description.PhysicalResourceDescription;
import schedframe.resources.units.ResourceUnit;
import schedframe.resources.units.ResourceUnitFactory;
import schedframe.resources.units.ResourceUnitName;
import schedframe.resources.utils.ResourceIdGenerator;
import schemas.ComputingResource;


public class ComputingResourceDescription extends PhysicalResourceDescription implements ExecutingResourceDescription {

        protected Map<ResourceUnitName, List<ResourceUnit>> resUnits;
        protected List<Device> devices;
        
        public ComputingResourceDescription(ComputingResource computingResource) {

                super(ResourceTypeFactory.createResourceType(computingResource.getClazz()));
                this.category = computingResource.getType();
                
                initId(computingResource);

                if (computingResource.getComputingResourceTypeChoiceSequence() != null) {
                        initResourceUnits(computingResource.getComputingResourceTypeChoiceSequence().getResourceUnit());
                        initProfiles(computingResource.getComputingResourceTypeChoiceSequence().getProfile());
                        initLocation(computingResource.getComputingResourceTypeChoiceSequence().getLocation());
                        initDevices(computingResource.getComputingResourceTypeChoiceSequence().getDevice());
                        this.parameters = extractParameters(computingResource.getComputingResourceTypeChoiceSequence().getParameter());
                }
        }

        private void initId(ComputingResource computingResource){
                this.id = computingResource.getName() != null ? computingResource.getName() : type.getName();
                if(computingResource.getCount() > 1 || computingResource.getName() == null){
                        this.id = id + "_" + String.valueOf(ResourceIdGenerator.getId(type.getName()));
                }
        }
        
        private void initResourceUnits(schemas.ResourceUnit[] resourceUnitCharacteristics) {
                for (int i = 0; i < resourceUnitCharacteristics.length; i++) {
                        schemas.ResourceUnit resourceUnitCharacteristic = resourceUnitCharacteristics[i];
                        ResourceUnit resourceUnit = ResourceUnitFactory.createUnit(resourceUnitCharacteristic.getClazz(), this.id,
                                         Double.valueOf(resourceUnitCharacteristic.getAmount().getContent()).intValue(), 0);
                        Parameters params = extractParameters(resourceUnitCharacteristic.getParameter());
                        resourceUnit.init(params);
                        addResourceUnit(resourceUnit);
                }
        }
        
        private void initDevices(schemas.Device[] dev) {
                if (dev != null){
                        this.devices = new ArrayList<Device>();
                        for(int i = 0; i < dev.length; i++){
                                Device device =  DeviceFactory.createDevice(new DeviceDescription(dev[i]));
                                this.devices.add(device);
                        }
                }
        }

        public String getCompResourceParameterValue(String name){
                return getParameters().get(name).get(0).getContent();
        }

        /*private Properties initProperties(schemas.Parameter[] parameters){
                Properties prop = new Properties();
                
                for(int i = 0; i < parameters.length; i++){
                        schemas.Parameter parameter = parameters[i];
                        List values = new ArrayList();
                        if(parameter.getParameterTypeSequence().getProperty() != null)
                        {
                                Map<String, List<StringValueWithUnit>> properties = new HashMap<String, List<StringValueWithUnit>>();
                                List<StringValueWithUnit> propValues = new ArrayList<StringValueWithUnit>();
                                for(int j = 0; j < parameter.getParameterTypeSequence().getPropertyCount(); j++){
                                        schemas.Property property = parameter.getParameterTypeSequence().getProperty(j);
                                        for(int k = 0; k < property.getStringValueWithUnitCount(); k++){
                                                propValues.add(property.getStringValueWithUnit(k));
                                        }
                                        properties.put(property.getName(), propValues);
                                }
                                values.add(properties);
                        }else {
                                for(int j = 0; j < parameter.getStringValueWithUnitCount(); j++){
                                        values.add(parameter.getStringValueWithUnit(j));
                                }
                        }
                        prop.put(parameter.getName(), values);
                }
                return prop;
        }*/


        public List<Device> getDevices() {
                return devices;
        }


        public void addResourceUnit(ResourceUnit unit) {
                if (this.resUnits == null)
                        this.resUnits = new HashMap<ResourceUnitName, List<ResourceUnit>>(1);
                List<ResourceUnit> list = null;
                if (this.resUnits.containsKey(unit.getName())) {
                        list = this.resUnits.get(unit.getName());
                } else {
                        list = new ArrayList<ResourceUnit>(1);
                        this.resUnits.put(unit.getName(), list);
                }
                list.add(unit);
        }
        
        public ResourceUnit getResourceUnit(ResourceUnitName unitName) throws NoSuchFieldException {
                return getResourceUnitList(unitName).get(0);
        }

        public List<ResourceUnit> getResourceUnitList(ResourceUnitName unitName) throws NoSuchFieldException {
                if (resUnits.containsKey(unitName))
                        return resUnits.get(unitName);
                else
                        throw new NoSuchFieldException("Resource unit " + unitName + " is not available in resource " + this.id);
        }

        public Collection<ResourceUnit> getResourceUnit() {
                if (resUnits == null)
                        return null;
                List<ResourceUnit> values = new ArrayList<ResourceUnit>();
                Collection<List<ResourceUnit>> lists = resUnits.values();
                Iterator<List<ResourceUnit>> itr = lists.iterator();

                while (itr.hasNext()) {
                        List<ResourceUnit> list = itr.next();
                        values.addAll(list);
                }

                return values;
        }

        public Map<ResourceUnitName, List<ResourceUnit>> getResourceUnits() {
                return resUnits;
        }
}