/ - Diff - Rozšíření nástroje IMiGEr (KIV) - HKMM - Redmine

.gitignore
	1	sources/.idea/
	2	sources/build/
	3	sources/WebContent/node_modules/

     	</context-param>
     	<context-param>
     		<param-name>DbPsw</param-name>
     		<param-value></param-value>
     		<param-value>NULL</param-value>
     	</context-param>
     	<context-param>
     		<param-name>HOME_URL</param-name>
-...
     	</context-param>
     	<context-param>
     		<param-name>storageLocation</param-name>
     		<param-value>C:\Users\adnuk\Documents\aswi\uloziste</param-value>
     		<param-value>C:\Users\Tomas\Documents\imiger\storage</param-value>
     	</context-param>
     	<context-param>
     		<param-name>crceApiBase</param-name>
     		<param-value>http://localhost:8081/rest/v2</param-value>
     		<param-name>configLocation</param-name>
     		<param-value>C:\Users\Tomas\Documents\imiger\config</param-value>
     	</context-param>
     	<context-param>

     package cz.zcu.kiv.offscreen;
     import cz.zcu.kiv.offscreen.graph.GraphManager;
     public class AttributeType {
         public String name;
         public GraphManager.AttributeDataType dataType;
         public String text;
         public AttributeType(String name, GraphManager.AttributeDataType dataType, String text) {
             this.name = name;
             this.dataType = dataType;
             this.text = text;
+        }
         public String getName() {
             return name;
+        }
         public GraphManager.AttributeDataType getDataType() {
             return dataType;
+        }
+    }

      */
     package cz.zcu.kiv.offscreen.api;
     import cz.zcu.kiv.offscreen.graph.SubedgeInfo;
     import java.util.List;
     /**
+     *
      * @author Jindra Pavlíková <jindra.pav2@seznam.cz>
-...
         public String getTo();
         public int getId();
         public List<SubedgeInfo> getSubedgeInfo();
         public void setSubedgeInfo(List<SubedgeInfo> subedgeInfo);
+    }

      */
     package cz.zcu.kiv.offscreen.api;
     import cz.zcu.kiv.offscreen.AttributeType;
     import cz.zcu.kiv.offscreen.graph.EdgeArchetype;
     import cz.zcu.kiv.offscreen.graph.VertexArchetype;
     import java.util.List;
     import java.util.Map;
-...
         public void addVertex(String name, VertexInterface vertex);
         public Map<String, VertexInterface> getVertices();
         public List<EdgeInterface> getEdges();
         public List<VertexArchetype>  getVertexArchetypes();
         public List<EdgeArchetype> getEdgeArchetypes();
         public void setVertexArchetypes(List<VertexArchetype> vertexArchetypes);
         public void setEdgeArchetypes(List<EdgeArchetype> edgeArchetypes);
         public void setAttributeTypes(List<AttributeType> attributeTypes);
         public void setPossibleEnumValues(Map<Integer, List<String>> possibleEnumValues);
         public List<AttributeType> getAttributeTypes();
         public Map<String, List<String>> getPossibleEnumValues();
         void setArchetypeIcons(Map<String, String> archetypeIcons);
         Map<String, String> getArchetypeIcons();
         List<Integer> getDefaultGroupArchetypes();
         void setDefaultGroupArchetypes(List<Integer> defaultGroupArchetypes);
+    }

     	public void setImportedPackages(List<String> importedPackages);
     	public int getArchetype();
     	public void setArchetype(int archetype);
     	public void setAttributes(List<String[]> attributes);
     	public List<String[]> getAttributes();
+    }

     /**
+     *
      */
     package cz.zcu.kiv.offscreen.data.efpportal;
     import java.util.HashMap;
     import java.util.Map;
     /**
+     *
      * Representation of EFPPortal's connections . A connection consists of a provided and required features.
+     *
      * @author Jiri Loudil
+     *
      */
     public class CocaexData {
     	/**
     	 * Map of all provided features.
     	 */
     	private Map<String, CocaexDataFeature> providedFeatures;
     	/**
     	 * Map of all required features.
     	 */
     	private Map<String, CocaexDataFeature> requiredFeatures;
     	public CocaexData() {
     		this.providedFeatures = new HashMap<String, CocaexDataFeature>();
     		this.requiredFeatures = new HashMap<String, CocaexDataFeature>();
+    	}
     	/**
     	 * @return the providedFeatures
     	 */
     	public Map<String, CocaexDataFeature> getProvidedFeatures() {
     		return providedFeatures;
+    	}
     	/**
     	 * @return the importedFeatures
     	 */
     	public Map<String, CocaexDataFeature> getRequiredFeatures() {
     		return requiredFeatures;
+    	}
+    }
     ///**
     // *
     // */
     //package cz.zcu.kiv.offscreen.data.efpportal;
     //
     //import java.util.HashMap;
     //import java.util.Map;
     //
     ///**
     // *
     // * Representation of EFPPortal's connections . A connection consists of a provided and required features.
     // *
     // * @author Jiri Loudil
     // *
     // */
     //public class CocaexData {
     //	/**
     //	 * Map of all provided features.
     //	 */
     //	private Map<String, CocaexDataFeature> providedFeatures;
     //
     //	/**
     //	 * Map of all required features.
     //	 */
     //	private Map<String, CocaexDataFeature> requiredFeatures;
     //
     //	public CocaexData() {
     //		this.providedFeatures = new HashMap<String, CocaexDataFeature>();
     //		this.requiredFeatures = new HashMap<String, CocaexDataFeature>();
     //	}
     //
     //	/**
     //	 * @return the providedFeatures
     //	 */
     //	public Map<String, CocaexDataFeature> getProvidedFeatures() {
     //		return providedFeatures;
     //	}
     //
     //	/**
     //	 * @return the importedFeatures
     //	 */
     //	public Map<String, CocaexDataFeature> getRequiredFeatures() {
     //		return requiredFeatures;
     //	}
     //
     //}

     package cz.zcu.kiv.offscreen.data.efpportal;
     import cz.zcu.kiv.efps.comparator.result.EfpEvalResult.MatchingResult;
     import cz.zcu.kiv.efps.types.datatypes.EfpValueType;
     /**
      * Holds EFP's data.
+     *
      * @author Jiri Loudil
+     *
      */
     public class CocaexDataEfp {
     	private String efpName;
     	private String efpValueTypeName;
     	private EfpValueType efpValue;
     	private MatchingResult typeError;
     	/**
     	 * @return the efpName
     	 */
     	public String getEfpName() {
     		return efpName;
+    	}
     	/**
     	 * @param efpName the efpName to set
     	 */
     	public void setEfpName(String efpName) {
     		this.efpName = efpName;
+    	}
     	/**
     	 * @return the efpValueTypeName
     	 */
     	public String getEfpValueTypeName() {
     		return efpValueTypeName;
+    	}
     	/**
     	 * @param efpValueTypeName the efpValueTypeName to set
     	 */
     	public void setEfpValueTypeName(String efpValueTypeName) {
     		this.efpValueTypeName = efpValueTypeName;
+    	}
     	/**
     	 * @return the efpValue
     	 */
     	public EfpValueType getEfpValue() {
     		return efpValue;
+    	}
     	/**
     	 * @param efpValue the efpValue to set
     	 */
     	public void setEfpValue(EfpValueType efpValue) {
     		this.efpValue = efpValue;
+    	}
     	/**
     	 * @return the typeError
     	 */
     	public MatchingResult getTypeError() {
     		return typeError;
+    	}
     	/**
     	 * @param typeError the typeError to set
     	 */
     	public void setTypeError(MatchingResult typeError) {
     		this.typeError = typeError;
+    	}
+    }
     //package cz.zcu.kiv.offscreen.data.efpportal;
     //
     //import cz.zcu.kiv.efps.comparator.result.EfpEvalResult.MatchingResult;
     //import cz.zcu.kiv.efps.types.datatypes.EfpValueType;
     //
     ///**
     // * Holds EFP's data.
     // *
     // * @author Jiri Loudil
     // *
     // */
     //public class CocaexDataEfp {
     //	private String efpName;
     //	private String efpValueTypeName;
     //	private EfpValueType efpValue;
     //	private MatchingResult typeError;
     //
     //	/**
     //	 * @return the efpName
     //	 */
     //	public String getEfpName() {
     //		return efpName;
     //	}
     //	/**
     //	 * @param efpName the efpName to set
     //	 */
     //	public void setEfpName(String efpName) {
     //		this.efpName = efpName;
     //	}
     //	/**
     //	 * @return the efpValueTypeName
     //	 */
     //	public String getEfpValueTypeName() {
     //		return efpValueTypeName;
     //	}
     //	/**
     //	 * @param efpValueTypeName the efpValueTypeName to set
     //	 */
     //	public void setEfpValueTypeName(String efpValueTypeName) {
     //		this.efpValueTypeName = efpValueTypeName;
     //	}
     //	/**
     //	 * @return the efpValue
     //	 */
     //	public EfpValueType getEfpValue() {
     //		return efpValue;
     //	}
     //	/**
     //	 * @param efpValue the efpValue to set
     //	 */
     //	public void setEfpValue(EfpValueType efpValue) {
     //		this.efpValue = efpValue;
     //	}
     //
     //	/**
     //	 * @return the typeError
     //	 */
     //	public MatchingResult getTypeError() {
     //		return typeError;
     //	}
     //
     //	/**
     //	 * @param typeError the typeError to set
     //	 */
     //	public void setTypeError(MatchingResult typeError) {
     //		this.typeError = typeError;
     //	}
     //
     //}

     package cz.zcu.kiv.offscreen.data.efpportal;
     import java.util.ArrayList;
     import java.util.List;
     /**
      * Holds feature's data.
+     *
      * @author Jiri Loudil
+     *
      */
     public class CocaexDataFeature {
     	private List<CocaexDataEfp> efps;
     	public CocaexDataFeature() {
     		this.efps = new ArrayList<CocaexDataEfp>();
+    	}
     	/**
     	 * @return the efps
     	 */
     	public List<CocaexDataEfp> getEfps() {
     		return efps;
+    	}
     	/**
     	 * @param efps the efps to set
     	 */
     	public void setEfps(List<CocaexDataEfp> efps) {
     		this.efps = efps;
+    	}
+    }
     //package cz.zcu.kiv.offscreen.data.efpportal;
     //
     //import java.util.ArrayList;
     //import java.util.List;
     //
     ///**
     // * Holds feature's data.
     // *
     // * @author Jiri Loudil
     // *
     // */
     //public class CocaexDataFeature {
     //	private List<CocaexDataEfp> efps;
     //
     //	public CocaexDataFeature() {
     //		this.efps = new ArrayList<CocaexDataEfp>();
     //	}
     //
     //	/**
     //	 * @return the efps
     //	 */
     //	public List<CocaexDataEfp> getEfps() {
     //		return efps;
     //	}
     //
     //	/**
     //	 * @param efps the efps to set
     //	 */
     //	public void setEfps(List<CocaexDataEfp> efps) {
     //		this.efps = efps;
     //	}
     //
     //}

     package cz.zcu.kiv.offscreen.data.efpportal;
     import java.util.Map;
     /**
+     *
      * EFPPortal export data wrapper. Contains mappings for feature connection names and EFPs names.
+     *
      * @author Jiri Loudil
+     *
      */
     public class CocaexWrapper {
     	/**
     	 * Feature names mapping.
     	 */
     	private Map<String, String> featureMappings;
     	/**
     	 * EFPs name s mapping.
     	 */
     	private Map<String, String> efpMappings;
     	/**
     	 * EFPPortal data with IDs instead of names for EFPs and Features.
     	 */
     	private Map<String, CocaexData> data;
     	/**
     	 * @return the featureMappings
     	 */
     	public Map<String, String> getFeatureMappings() {
     		return featureMappings;
+    	}
     	/**
     	 * @param featureMappings the featureMappings to set
     	 */
     	public void setFeatureMappings(Map<String, String> featureMappings) {
     		this.featureMappings = featureMappings;
+    	}
     	/**
     	 * @return the efpMappings
     	 */
     	public Map<String, String> getEfpMappings() {
     		return efpMappings;
+    	}
     	/**
     	 * @param efpMappings the efpMappings to set
     	 */
     	public void setEfpMappings(Map<String, String> efpMappings) {
     		this.efpMappings = efpMappings;
+    	}
     	/**
     	 * @return the data
     	 */
     	public Map<String, CocaexData> getData() {
     		return data;
+    	}
     	/**
     	 * @param data the data to set
     	 */
     	public void setData(Map<String, CocaexData> data) {
     		this.data = data;
+    	}
+    }
     //package cz.zcu.kiv.offscreen.data.efpportal;
     //
     //import java.util.Map;
     //
     ///**
     // *
     // * EFPPortal export data wrapper. Contains mappings for feature connection names and EFPs names.
     // *
     // * @author Jiri Loudil
     // *
     // */
     //public class CocaexWrapper {
     //	/**
     //	 * Feature names mapping.
     //	 */
     //	private Map<String, String> featureMappings;
     //
     //	/**
     //	 * EFPs name s mapping.
     //	 */
     //	private Map<String, String> efpMappings;
     //
     //	/**
     //	 * EFPPortal data with IDs instead of names for EFPs and Features.
     //	 */
     //	private Map<String, CocaexData> data;
     //
     //	/**
     //	 * @return the featureMappings
     //	 */
     //	public Map<String, String> getFeatureMappings() {
     //		return featureMappings;
     //	}
     //	/**
     //	 * @param featureMappings the featureMappings to set
     //	 */
     //	public void setFeatureMappings(Map<String, String> featureMappings) {
     //		this.featureMappings = featureMappings;
     //	}
     //	/**
     //	 * @return the efpMappings
     //	 */
     //	public Map<String, String> getEfpMappings() {
     //		return efpMappings;
     //	}
     //	/**
     //	 * @param efpMappings the efpMappings to set
     //	 */
     //	public void setEfpMappings(Map<String, String> efpMappings) {
     //		this.efpMappings = efpMappings;
     //	}
     //	/**
     //	 * @return the data
     //	 */
     //	public Map<String, CocaexData> getData() {
     //		return data;
     //	}
     //	/**
     //	 * @param data the data to set
     //	 */
     //	public void setData(Map<String, CocaexData> data) {
     //		this.data = data;
     //	}
     //
     //
     //}

     package cz.zcu.kiv.offscreen.efp.utils;
     import java.io.ByteArrayInputStream;
     import java.io.IOException;
     import java.util.zip.GZIPInputStream;
     import javax.servlet.http.HttpServletRequest;
     import org.apache.log4j.Logger;
     import net.sf.json.JSONObject;
     import org.apache.commons.codec.binary.Base64;
     import org.apache.commons.io.IOUtils;
     import com.google.gson.Gson;
     import com.google.gson.GsonBuilder;
     import cz.zcu.kiv.efps.types.datatypes.EfpValueType;
     import cz.zcu.kiv.efps.types.serialisation.json.EfpValueTypeAdapter;
     import cz.zcu.kiv.offscreen.api.GraphInterface;
     import cz.zcu.kiv.offscreen.data.efpportal.CocaexWrapper;
     import cz.zcu.kiv.offscreen.graph.GraphExport;
     import cz.zcu.kiv.offscreen.graph.creator.EfpGraphTransfomer;
     /**
+     *
      * Transofma and decompress tools for incoming JSON.
+     *
      * @author Jiri Loudil
+     *
      */
     public class JsonTransformer {
     	private Logger logger = Logger.getLogger(JsonTransformer.class);
     	/**
+    	 *
     	 * Deserialize input JSON and transform to graph JSON.
+    	 *
     	 * @param inputJSON
     	 * @param request
     	 * @return
     	 * @throws IOException
     	 */
     	public String transformInputJSONToGraphJSON(String inputJSON,
     			HttpServletRequest request) throws IOException {
     		CocaexWrapper efpResults;
     		GsonBuilder gsonBuilder = new GsonBuilder();
     		// JSON deserializing adapter provided for EFP type classes
     		gsonBuilder.registerTypeAdapter(EfpValueType.class,
     				new EfpValueTypeAdapter());
     		// JSON deserializing adapter for the Wrapper class
     		gsonBuilder.registerTypeAdapter(CocaexWrapper.class,
     				new WrapperDeserializer());
     		Gson gson = gsonBuilder.create();
     		// decode + unzip received data
     		String data = decompress(inputJSON);
     		// deserialize using deserializer adapters
     		efpResults = gson.fromJson(data, CocaexWrapper.class);
     		request.setAttribute("efpPortalEfpNames", efpResults.getEfpMappings());
     		// transform received data to readable graph form
     		EfpGraphTransfomer transformer = new EfpGraphTransfomer(efpResults);
     		GraphInterface graph = transformer.transform();
     		GraphExport export = new GraphExport(graph);
     		// transform graph to JSON
     		JSONObject o = JSONObject.fromObject(export);
     		return o.toString();
+    	}
     	/**
     	 * Decode and unzip a Base64 encoded GZIPed string.
+    	 *
     	 * @param input
     	 * @return
     	 * @throws IOException
     	 */
     	private String decompress(String input) throws IOException {
     		logger.trace("ENTRY");
     		String result = null;
     		byte[] bytes = Base64.decodeBase64(input);
     		GZIPInputStream zi = null;
     		try {
     			zi = new GZIPInputStream(new ByteArrayInputStream(bytes));
     			result = IOUtils.toString(zi);
     		} finally {
     			IOUtils.closeQuietly(zi);
+    		}
     		logger.trace("EXIT");
     		return result;
+    	}
+    }
     //package cz.zcu.kiv.offscreen.efp.utils;
     //
     //import java.io.ByteArrayInputStream;
     //import java.io.IOException;
     //import java.util.zip.GZIPInputStream;
     //
     //import javax.servlet.http.HttpServletRequest;
     //
     //import org.apache.log4j.Logger;
     //
     //import net.sf.json.JSONObject;
     //
     //import org.apache.commons.codec.binary.Base64;
     //import org.apache.commons.io.IOUtils;
     //
     //import com.google.gson.Gson;
     //import com.google.gson.GsonBuilder;
     //
     //import cz.zcu.kiv.efps.types.datatypes.EfpValueType;
     //import cz.zcu.kiv.efps.types.serialisation.json.EfpValueTypeAdapter;
     //import cz.zcu.kiv.offscreen.api.GraphInterface;
     //import cz.zcu.kiv.offscreen.data.efpportal.CocaexWrapper;
     //import cz.zcu.kiv.offscreen.graph.GraphExport;
     //import cz.zcu.kiv.offscreen.graph.creator.EfpGraphTransfomer;
     //
     ///**
     // *
     // * Transofma and decompress tools for incoming JSON.
     // *
     // * @author Jiri Loudil
     // *
     // */
     //public class JsonTransformer {
     //	private Logger logger = Logger.getLogger(JsonTransformer.class);
     //
     //	/**
     //	 *
     //	 * Deserialize input JSON and transform to graph JSON.
     //	 *
     //	 * @param inputJSON
     //	 * @param request
     //	 * @return
     //	 * @throws IOException
     //	 */
     //	public String transformInputJSONToGraphJSON(String inputJSON,
     //			HttpServletRequest request) throws IOException {
     //		CocaexWrapper efpResults;
     //
     //		GsonBuilder gsonBuilder = new GsonBuilder();
     //		// JSON deserializing adapter provided for EFP type classes
     //		gsonBuilder.registerTypeAdapter(EfpValueType.class,
     //				new EfpValueTypeAdapter());
     //		// JSON deserializing adapter for the Wrapper class
     //		gsonBuilder.registerTypeAdapter(CocaexWrapper.class,
     //				new WrapperDeserializer());
     //		Gson gson = gsonBuilder.create();
     //
     //		// decode + unzip received data
     //		String data = decompress(inputJSON);
     //
     //		// deserialize using deserializer adapters
     //		efpResults = gson.fromJson(data, CocaexWrapper.class);
     //
     //		request.setAttribute("efpPortalEfpNames", efpResults.getEfpMappings());
     //
     //		// transform received data to readable graph form
     //		EfpGraphTransfomer transformer = new EfpGraphTransfomer(efpResults);
     //		GraphInterface graph = transformer.transform();
     //		GraphExport export = new GraphExport(graph);
     //
     //		// transform graph to JSON
     //		JSONObject o = JSONObject.fromObject(export);
     //
     //		return o.toString();
     //	}
     //
     //	/**
     //	 * Decode and unzip a Base64 encoded GZIPed string.
     //	 *
     //	 * @param input
     //	 * @return
     //	 * @throws IOException
     //	 */
     //	private String decompress(String input) throws IOException {
     //		logger.trace("ENTRY");
     //		String result = null;
     //
     //		byte[] bytes = Base64.decodeBase64(input);
     //		GZIPInputStream zi = null;
     //		try {
     //			zi = new GZIPInputStream(new ByteArrayInputStream(bytes));
     //			result = IOUtils.toString(zi);
     //		} finally {
     //			IOUtils.closeQuietly(zi);
     //		}
     //		logger.trace("EXIT");
     //
     //		return result;
     //	}
     //
     //}

     package cz.zcu.kiv.offscreen.efp.utils;
     import java.lang.reflect.Type;
     import java.util.HashMap;
     import java.util.Map;
     import org.apache.log4j.Logger;
     import com.google.gson.Gson;
     import com.google.gson.GsonBuilder;
     import com.google.gson.JsonDeserializationContext;
     import com.google.gson.JsonDeserializer;
     import com.google.gson.JsonElement;
     import com.google.gson.JsonObject;
     import cz.zcu.kiv.efps.types.datatypes.EfpValueType;
     import cz.zcu.kiv.efps.types.serialisation.json.EfpValueTypeAdapter;
     import cz.zcu.kiv.offscreen.data.efpportal.CocaexData;
     import cz.zcu.kiv.offscreen.data.efpportal.CocaexWrapper;
     /**
+     *
      * CocaexWrapper class deserializer.
+     *
      * @author Jiri Loudil
+     *
      */
     public class WrapperDeserializer implements JsonDeserializer<CocaexWrapper> {
     	private Logger logger = Logger.getLogger(WrapperDeserializer.class);
     	@Override
     	public CocaexWrapper deserialize(JsonElement json, Type typeOfT,
     			JsonDeserializationContext context) {
     		logger.trace("ENTRY");
     		GsonBuilder gsonBuilder = new GsonBuilder();
     		// JSON deserializing adapter provided for EFP type classes
     		gsonBuilder.registerTypeAdapter(EfpValueType.class,
     				new EfpValueTypeAdapter());
     		Gson gson = gsonBuilder.create();
     		CocaexWrapper wrapper = gson.fromJson(json, CocaexWrapper.class);
     		JsonObject jo = json.getAsJsonObject();
     		Map<String, String> featureMappings = new HashMap<String, String>();
     		Map<String, String> efpMappings = new HashMap<String, String>();
     		Map<String, CocaexData> data = new HashMap<String, CocaexData>();
     		// parse feature mappings
     		JsonObject featuresObject = jo.getAsJsonObject("featureMappings");
     		for (Map.Entry<String, JsonElement> entry : featuresObject.entrySet()) {
     			featureMappings.put(entry.getKey(), entry.getValue().getAsString());
+    		}
     		// parse efps mappings
     		JsonObject efpsObject = jo.getAsJsonObject("efpMappings");
     		for (Map.Entry<String, JsonElement> entry : efpsObject.entrySet()) {
     			efpMappings.put(entry.getKey(), entry.getValue().getAsString());
+    		}
     		// parse data
     		JsonObject dataObject = jo.getAsJsonObject("data");
     		for (Map.Entry<String, JsonElement> entry : dataObject.entrySet()) {
     			data.put(entry.getKey(), (CocaexData) context.deserialize(
     					entry.getValue(), CocaexData.class));
+    		}
     		// fill output structure
     		wrapper.setFeatureMappings(featureMappings);
     		wrapper.setEfpMappings(efpMappings);
     		wrapper.setData(data);
     		logger.trace("EXIT");
     		return wrapper;
+    	}
+    }
     //package cz.zcu.kiv.offscreen.efp.utils;
     //
     //import java.lang.reflect.Type;
     //import java.util.HashMap;
     //import java.util.Map;
     //
     //import org.apache.log4j.Logger;
     //
     //import com.google.gson.Gson;
     //import com.google.gson.GsonBuilder;
     //import com.google.gson.JsonDeserializationContext;
     //import com.google.gson.JsonDeserializer;
     //import com.google.gson.JsonElement;
     //import com.google.gson.JsonObject;
     //
     //import cz.zcu.kiv.efps.types.datatypes.EfpValueType;
     //import cz.zcu.kiv.efps.types.serialisation.json.EfpValueTypeAdapter;
     //import cz.zcu.kiv.offscreen.data.efpportal.CocaexData;
     //import cz.zcu.kiv.offscreen.data.efpportal.CocaexWrapper;
     //
     ///**
     // *
     // * CocaexWrapper class deserializer.
     // *
     // * @author Jiri Loudil
     // *
     // */
     //public class WrapperDeserializer implements JsonDeserializer<CocaexWrapper> {
     //	private Logger logger = Logger.getLogger(WrapperDeserializer.class);
     //
     //	@Override
     //	public CocaexWrapper deserialize(JsonElement json, Type typeOfT,
     //			JsonDeserializationContext context) {
     //		logger.trace("ENTRY");
     //
     //		GsonBuilder gsonBuilder = new GsonBuilder();
     //		// JSON deserializing adapter provided for EFP type classes
     //		gsonBuilder.registerTypeAdapter(EfpValueType.class,
     //				new EfpValueTypeAdapter());
     //		Gson gson = gsonBuilder.create();
     //
     //		CocaexWrapper wrapper = gson.fromJson(json, CocaexWrapper.class);
     //		JsonObject jo = json.getAsJsonObject();
     //
     //		Map<String, String> featureMappings = new HashMap<String, String>();
     //		Map<String, String> efpMappings = new HashMap<String, String>();
     //		Map<String, CocaexData> data = new HashMap<String, CocaexData>();
     //
     //		// parse feature mappings
     //		JsonObject featuresObject = jo.getAsJsonObject("featureMappings");
     //		for (Map.Entry<String, JsonElement> entry : featuresObject.entrySet()) {
     //			featureMappings.put(entry.getKey(), entry.getValue().getAsString());
     //		}
     //
     //		// parse efps mappings
     //		JsonObject efpsObject = jo.getAsJsonObject("efpMappings");
     //		for (Map.Entry<String, JsonElement> entry : efpsObject.entrySet()) {
     //			efpMappings.put(entry.getKey(), entry.getValue().getAsString());
     //		}
     //
     //		// parse data
     //		JsonObject dataObject = jo.getAsJsonObject("data");
     //		for (Map.Entry<String, JsonElement> entry : dataObject.entrySet()) {
     //			data.put(entry.getKey(), (CocaexData) context.deserialize(
     //					entry.getValue(), CocaexData.class));
     //		}
     //
     //		// fill output structure
     //		wrapper.setFeatureMappings(featureMappings);
     //		wrapper.setEfpMappings(efpMappings);
     //		wrapper.setData(data);
     //		logger.trace("EXIT");
     //
     //		return wrapper;
     //	}
     //}

     package cz.zcu.kiv.offscreen.graph;
     public class Attribute {
         int typeIndex;
         Object value;
         public Attribute(int typeIndex, Object value) {
             this.typeIndex = typeIndex;
             this.value = value;
+        }
+    }

     package cz.zcu.kiv.offscreen.graph;
     public class EdgeArchetype {
         public String name;
         public String text;
         EdgeArchetype(String name, String text) {
             this.name = name;
             this.text = text;
+        }
         public String getName() {
             return  name;
+        }
+    }

     package cz.zcu.kiv.offscreen.graph;
     public class EdgeArchetypeInfo {
         /**
          * index of the archetype of the vertex the edge leads to
          */
         public int fromArchetypeIndex;
         /**
          * index of the archetype of the edge
          */
         public int edgeArchetypeIndex;
         /**
          * index of the archetype of the vertex the edge leads from
          */
         public int toArchetypeIndex;
         public EdgeArchetypeInfo(int fromArchetypeIndex, int edgeArchetypeIndex, int toArchetypeIndex) {
             this.fromArchetypeIndex = fromArchetypeIndex;
             this.edgeArchetypeIndex = edgeArchetypeIndex;
             this.toArchetypeIndex = toArchetypeIndex;
+        }
         @Override
         public int hashCode() {
             return fromArchetypeIndex * 10000 + edgeArchetypeIndex * 100 + fromArchetypeIndex;
+        }
         @Override
         public boolean equals(Object obj) {
             EdgeArchetypeInfo info = (EdgeArchetypeInfo)obj;
             return (info.fromArchetypeIndex == fromArchetypeIndex) && (info.edgeArchetypeIndex == edgeArchetypeIndex) && (info.toArchetypeIndex == toArchetypeIndex);
+        }
+    }

     package cz.zcu.kiv.offscreen.graph;
     import java.util.*;
     public class EdgeData {
         public int id;
         public int from;
         public int to;
         public String text;
         public int archetypeIndex;
         public Map<Integer, Attribute> attributes = new HashMap<>();
         public EdgeData(int id, int from, int to, String text, int archetypeIndex) {
             this.id = id;
             this.from = from;
             this.to = to;
             this.text = text;
             this.archetypeIndex = archetypeIndex;
+        }
         public void addAttribute(int attrTypeIndex, Object value) {
             Attribute attr = new Attribute(attrTypeIndex, value);
             attributes.put(attrTypeIndex, attr);
+        }
         public void addAttributes(Map<Integer, Attribute> attributes) {
             this.attributes.putAll(attributes);
+        }
         public Attribute getAttribute(int attrTypeIndex) {
             return attributes.get(attrTypeIndex);
+        }
         @Override
         public int hashCode() {
             return from * 100000 + to;
+        }
         @Override
         public boolean equals(Object edge) {
             return from == ((EdgeData) edge).from && to == ((EdgeData) edge).to;
+        }
         public List<Attribute> getSortedAttributes() {
             List<Attribute> list = new ArrayList<>();
             ArrayList<Integer> indices = new ArrayList<>(attributes.keySet());
             //indices.sort(Integer::compareTo);
             Collections.sort(indices); // TODO check correct order
             for (int i = 0; i < indices.size(); i++) {
                 list.add(attributes.get(indices.get(i)));
+            }
             return list;
+        }
+    }

     package cz.zcu.kiv.offscreen.graph;
     import java.util.ArrayList;
     import java.util.List;
     import org.apache.log4j.Logger;
-...
     		return edgeId;
+    	}
     	@Override
     	public List<SubedgeInfo> getSubedgeInfo() {
     		return null;
+    	}
     	@Override
     	public void setSubedgeInfo(List<SubedgeInfo> subedgeInfo) {
     		// TODO 30.7.2018 empty body (copy from CoCaEx ASWI)
+    	}
     	public ArrayList<EfpFeature> getFeatures() {
     		return features;
+    	}

         private String to;
         private List<String> packageConnections;
         private boolean isCompatible;
         private List<SubedgeInfo> subedgeInfo;
         private String compInfoJSON;
         private Logger logger = Logger.getLogger(EdgeImpl.class);
-...
             return edgeId;
+        }
         @Override
         public List<SubedgeInfo> getSubedgeInfo() {
             return subedgeInfo;
+        }
         @Override
         public void setSubedgeInfo(List<SubedgeInfo> subedgeInfo) {
             this.subedgeInfo = subedgeInfo;
+        }
         @Override
         public boolean equals(Object edge) {
             if (!(edge instanceof EdgeImpl)) return false;
             EdgeImpl cmpEdge = (EdgeImpl) edge;
             return from.equals(cmpEdge.from) && to.equals(cmpEdge.to);
+        }
         public List<String> getPackageConnections() {
             logger.trace("ENTRY");
             logger.trace("EXIT");
             return this.packageConnections;
+        }
         public void setPackageConnection(List<String> packageConnections) {
         public void setPackageConnections(List<String> packageConnections) {
             logger.trace("ENTRY");
             this.packageConnections = packageConnections;
             logger.trace("EXIT");

     package cz.zcu.kiv.offscreen.graph;
     import cz.zcu.kiv.offscreen.AttributeType;
     import cz.zcu.kiv.offscreen.api.EdgeInterface;
     import cz.zcu.kiv.offscreen.api.GraphInterface;
     import cz.zcu.kiv.offscreen.api.VertexInterface;
     import java.util.ArrayList;
     import java.util.List;
     import java.util.Map;
     import org.apache.log4j.Logger;
     /*
-...
         private List<VertexInterface> vertices;
         private List<EdgeInterface> edges;
         private List<VertexArchetype> vertexArchetypes;
         private List<EdgeArchetype> edgeArchetypes;
         private List<AttributeType> attributeTypes;
         private Map<String, List<String>> possibleEnumValues;
         private Map<String, String> archetypeIcons;
         private List<Integer> defaultGroupArchetypes;
         private Logger logger = Logger.getLogger(GraphExport.class);
         public GraphExport(GraphInterface graph) {
             logger.trace("ENTRY");
             this.vertices = new ArrayList<VertexInterface>(graph.getVertices().values());
             this.edges = new ArrayList<EdgeInterface>(graph.getEdges());
             this.vertexArchetypes = new ArrayList<VertexArchetype>(graph.getVertexArchetypes());
             this.edgeArchetypes = new ArrayList<EdgeArchetype>(graph.getEdgeArchetypes());
             this.attributeTypes = new ArrayList<>(graph.getAttributeTypes());
             this.possibleEnumValues = graph.getPossibleEnumValues();
             this.archetypeIcons = graph.getArchetypeIcons();
             this.defaultGroupArchetypes = graph.getDefaultGroupArchetypes();
             logger.trace("EXIT");
+        }
-...
             logger.trace("EXIT");
             return vertices;
+        }
         public List<VertexArchetype> getVertexArchetypes() {
             return vertexArchetypes;
+        }
         public List<EdgeArchetype> getEdgeArchetypes() {
             return edgeArchetypes;
+        }
         public List<AttributeType> getAttributeTypes() {
             return attributeTypes;
+        }
         public Map<String, List<String>> getPossibleEnumValues() {
             return possibleEnumValues;
+        }
         public Map<String, String> getArchetypeIcons() {
             return archetypeIcons;
+        }
         public List<Integer> getDefaultGroupArchetypes() {
             return defaultGroupArchetypes;
+        }
+    }

     package cz.zcu.kiv.offscreen.graph;
     import cz.zcu.kiv.offscreen.AttributeType;
     import cz.zcu.kiv.offscreen.api.EdgeInterface;
     import cz.zcu.kiv.offscreen.api.GraphInterface;
     import cz.zcu.kiv.offscreen.api.VertexInterface;
-...
         private Map<String, VertexInterface> vertices;
         private List<EdgeInterface> edges;
         private Logger logger = Logger.getLogger(GraphImpl.class);
         private List<VertexArchetype> vertexArchetypes;
         private List<EdgeArchetype> edgeArchetypes;
         private List<AttributeType> attributeTypes;
         private Map<String, List<String>> possibleEnumValues;
         private List<Integer> defaultGroupArchetypes;
         private Map<String, String> archetypeIcons;
         public GraphImpl() {
             logger.trace("ENTRY");
-...
             return edges;
+        }
         @Override
         public List<VertexArchetype> getVertexArchetypes() {
             return vertexArchetypes;
+        }
         @Override
         public List<EdgeArchetype> getEdgeArchetypes() {
             return edgeArchetypes;
+        }
         @Override
         public void setVertexArchetypes(List<VertexArchetype> vertexArchetypes) {
             this.vertexArchetypes = vertexArchetypes;
+        }
         @Override
         public  void setEdgeArchetypes(List<EdgeArchetype> edgeArchetypes) {
             this.edgeArchetypes = edgeArchetypes;
+        }
         @Override
         public void setAttributeTypes(List<AttributeType> attributeTypes) {
             this.attributeTypes = attributeTypes;
+        }
         @Override
         public void setPossibleEnumValues(Map<Integer, List<String>> possibleEnumValues) {
             this.possibleEnumValues = new HashMap<>();
             for (Integer index : possibleEnumValues.keySet()) {
                 this.possibleEnumValues.put("" + index, possibleEnumValues.get(index));
+            }
+        }
         public void setArchetypeIcons(Map<String, String> archetypeIcons) {
             this.archetypeIcons = archetypeIcons;
+        }
         @Override
         public List<Integer> getDefaultGroupArchetypes() {
             return defaultGroupArchetypes;
+        }
         @Override
         public void setDefaultGroupArchetypes(List<Integer> defaultGroupArchetypes) {
             this.defaultGroupArchetypes = defaultGroupArchetypes;
+        }
         @Override
         public List<AttributeType> getAttributeTypes() {
             return attributeTypes;
+        }
         @Override
         public Map<String, List<String>> getPossibleEnumValues() {
             return possibleEnumValues;
+        }
         @Override
         public Map<String, String> getArchetypeIcons() {
             return archetypeIcons;
+        }
         @Override
         public Map<String, VertexInterface> getVertices() {
             logger.trace("ENTRY");

     package cz.zcu.kiv.offscreen.graph;
     import cz.zcu.kiv.offscreen.AttributeType;
     import cz.zcu.kiv.offscreen.api.GraphInterface;
     import cz.zcu.kiv.offscreen.api.VertexInterface;
     import cz.zcu.kiv.offscreen.graph.filter.*;
     import cz.zcu.kiv.offscreen.graph.loader.JSONConfigLoader;
     import java.util.*;
     public class GraphManager {
         public enum AttributeDataType {
             NUMBER {
                 @Override
                 public String toString() {
                     return "number";
+                }
             },
             DATE {
                 @Override
                 public String toString() {
                     return "date";
+                }
             },
             ENUM {
                 @Override
                 public String toString() {
                     return "enum";
+                }
             },
             STRING {
                 @Override
                 public String toString() {
                     return "string";
+                }
+            }
+        }
         public List<VertexArchetype> vertexArchetypes = new ArrayList<>();
         public List<EdgeArchetype> edgeArchetypes = new ArrayList<>();
         public List<AttributeType> attributeTypes = new ArrayList<>();
         /**
          * the key is the attributeType index, the value is the list of possible values
          */
         private Map<Integer, List<String>> possibleEnumValues = new HashMap<>();
         /**
          * key is the archetype index, value is the set of vertices of the given archetype
          */
         public Map<Integer, HashSet<VertexData>> vertices = new HashMap<>();
         /**
          * key is the triplet of archetypes {fromVertex, edge, toVertex}, value is the list of edges for the given archetype triplet
          */
         public Map<EdgeArchetypeInfo, List<EdgeData>> edges = new HashMap<>();
         public void addVertexArchetype(String name, String text) {
             vertexArchetypes.add(new VertexArchetype(name, text));
+        }
         public void addEdgeArchetype(String name, String text) {
             edgeArchetypes.add(new EdgeArchetype(name, text));
+        }
         /**
+         *
          * @param name
          * @param dataType
          * @param text
          */
         public void addAttributeType(String name, AttributeDataType dataType, String text) {
             attributeTypes.add(new AttributeType(name, dataType, text));
+        }
         /**
          * Adds a list of values to the possible values hashmap. All duplicated are
          * removed.
+         *
          * @param attributeTypeId - Id of attribute type
          * @param values          - List of values of the corresponding attribute type
          */
         public void addUniquePossibleAttributeValues(int attributeTypeId, List<String> values) {
             if (possibleEnumValues.containsKey(attributeTypeId)) {
                 List<String> attrValues = possibleEnumValues.get(attributeTypeId);
                 List<String> valuesWithoutDuplicates = new ArrayList<>(new HashSet<>(values)); // Converting to hashset removes duplicates
                 valuesWithoutDuplicates.removeAll(attrValues);   // Values to add without values already present in the hashmap
                 attrValues.addAll(valuesWithoutDuplicates);
             } else {
                 possibleEnumValues.put(attributeTypeId, values);
+            }
+        }
         public List<Integer> getEnumPositionsForAttrIndex(int attributeTypeId, List<String> enumValues) {
             List<Integer> positions = new ArrayList<>();
             if (!possibleEnumValues.containsKey(attributeTypeId)) {
                 return positions;
+            }
             List<String> possibleValues = possibleEnumValues.get(attributeTypeId);
             for (int i = 0; i < possibleValues.size(); i++) {
                 String possibleValue = possibleValues.get(i);
                 if (enumValues.contains(possibleValue)) {
                     positions.add(i);
+                }
+            }
             return positions;
+        }
         /**
          * Gets string values from possible enums for attribute type id.
          * @param attributeTypeId - Id of the attribute type
          * @param valuePositions - List of positions in the possible enums hashmap for which to find the enum values.
          * @return - List of string values of enums.
          */
         private List<String> getEnumStringsForAttrIndex(int attributeTypeId, List<Integer> valuePositions) {
             List<String> values = new ArrayList<>();
             List<String> possibleValues = possibleEnumValues.get(attributeTypeId);
             for (int i = 0; i < possibleValues.size(); i++) {
                 if (valuePositions.contains(i)) {
                     values.add(possibleValues.get(i));
+                }
+            }
             return values;
+        }
         public AttributeType getAttributeDataTypeByName(String attributeName) {
             return attributeTypes.get(getAttributeIndex(attributeName));
+        }
         /**
          * Adds a record to the possibleEnumValues hashset of the attributes possible values.
+         *
          * @param attributeIndex - Index of the attribute for which to add the possible values
          * @param possibleValues - All the possible values of the attribute
          */
         public void addEnumValues(int attributeIndex, List<String> possibleValues) {
             possibleEnumValues.put(attributeIndex, possibleValues);
+        }
         /**
          * Creates a new vertex from input parameters and adds it to the map of
          * vertices with the archetypeIndex as the key.
+         *
          * @param id             - ID of the vertex to add
          * @param title          - Title of the vertex
          * @param text           - Text of the vertex
          * @param archetypeIndex - Type of archetype associated with this vertex

Projekt

Obecné

Profil

ASWI - Pokročilé softwarové inženýrství » ASWI 2019 » Rozšíření nástroje IMiGEr (KIV) - HKMM

Revize ba05f7dc

Přidáno uživatelem Tomáš Šimandl před více než 6 roky(ů)