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

     package cz.zcu.kiv.offscreen.api;
     /**
      * Class represents edge. Class contains attributes which are common for input JSON format and for
      * output JSON format (JSON between frontend and backend)
      */
     public class BaseEdge {
         /** identification number of edge */
         private int id;
         /** original ID of vertex from edge leads */
         private int from;
         /** original ID of vertex where edge leads */
         private int to;
         /** additional info */
         private String text;
         public BaseEdge(int id, int from, int to, String text) {
             this.id = id;
             this.from = from;
             this.to = to;
             this.text = text;
+        }
         public int getId() {
             return id;
+        }
         public void setId(int id) {
             this.id = id;
+        }
         public int getFrom() {
             return from;
+        }
         public void setFrom(int from) {
             this.from = from;
+        }
         public int getTo() {
             return to;
+        }
         public void setTo(int to) {
             this.to = to;
+        }
         public String getText() {
             return text;
+        }
         public void setText(String text) {
             this.text = text;
+        }
         /**
          * Generate hash code based on attributes {@code from} and {@code to}.
          * @return generated hash code.
          */
         @Override
         public int hashCode() {
             return from * 100000 + to;
+        }
         /**
          * Two edges are equals where their {@code from} and {@code to} are equals.
+         *
          * @param edge which will be compared with this instance
          * @return tru if edges are equal, false otherwise
          */
         @Override
         public boolean equals(Object edge) {
             if (!(edge instanceof BaseEdge)) return false;
             BaseEdge cmpEdge = (BaseEdge) edge;
             return from == cmpEdge.from && to == cmpEdge.to;
+        }
+    }

     package cz.zcu.kiv.offscreen.api;
     /**
      * Class represents vertex. Class contains attributes which are common for input JSON format and for
      * output JSON format (JSON between frontend and backend)
      */
     public class BaseVertex {
         /** New generated identification number. */
         private int id;
         /** Identification number which is in input file. */
         private int originalId;
         /** Title of vertex. */
         private String title;
         /** Index of vertex archetype. */
         private int archetypeIndex;
         /** Additional info. */
         private String text;
         public BaseVertex(int id, int originalId, String title, int archetypeIndex, String text) {
             this.id = id;
             this.originalId = originalId;
             this.title = title;
             this.archetypeIndex = archetypeIndex;
             this.text = text;
+        }
         public int getId() {
             return id;
+        }
         public void setId(int id) {
             this.id = id;
+        }
         public int getOriginalId() {
             return originalId;
+        }
         public void setOriginalId(int originalId) {
             this.originalId = originalId;
+        }
         public String getTitle() {
             return title;
+        }
         public void setTitle(String title) {
             this.title = title;
+        }
         public int getArchetype() {
             return archetypeIndex;
+        }
         public void setArchetype(int archetypeIndex) {
             this.archetypeIndex = archetypeIndex;
+        }
         public String getText() {
             return text;
+        }
         public void setText(String text) {
             this.text = text;
+        }
         /**
          * Generate hash code which is based on {@code originalId}.
          * @return generated has code
          */
         @Override
         public int hashCode() {
             return originalId;
+        }
         /**
          * Two vertices are equals when their {@code originalId} is equals.
          * @param edge which will be compared with this instance
          * @return true if vertices are equal, false otherwise
          */
         @Override
         public boolean equals(Object edge) {
             if (!(edge instanceof BaseVertex)) return false;
             return originalId == ((BaseVertex) edge).originalId;
+        }
+    }

     package cz.zcu.kiv.offscreen.api;
     import java.util.List;
     /**
      * Class represents edge which is used for output JSON format (JSON between frontend and backend).
      */
     public class Edge extends BaseEdge {
         /**
          * List of subedgeInfo.
          * When two input edges are equals, in output their are in one record and their differences are in subedgeInfo.
          */
         private List<SubedgeInfo> subedgeInfo;
         /**
          * Create new edge.
          * @param id new generated identification number
          * @param from original ID of vertex from edge leads
          * @param to original ID of vertex where edge leads
          * @param text additional info
          * @param subedgeInfo list which contains differences between equals edges
          */
         public Edge(int id, int from, int to, String text, List<SubedgeInfo> subedgeInfo) {
             super(id, from, to, text);
             this.subedgeInfo = subedgeInfo;
+        }
         public List<SubedgeInfo> getSubedgeInfo(){
             return subedgeInfo;
+        }
         public void setSubedgeInfo(List<SubedgeInfo> subedgeInfo) {
             this.subedgeInfo = subedgeInfo;
+        }
+    }

     package cz.zcu.kiv.offscreen.api;
     import cz.zcu.kiv.offscreen.graph.*;
     import java.util.ArrayList;
     import java.util.List;
     import java.util.Map;
     import org.apache.log4j.Logger;
     /**
      * Class represents graph with all information about graph plus information about state in which used store graph.
      * Class is used for creating of JSON which is send to frontend.
      */
     public class GraphExport {
         private List<Vertex> vertices;
         private List<Edge> 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<Group> groups;
         private List<Position> positions;
         private List<SideBar> sideBar;
         private int selectedVertex;
         private int selectedEdge;
         private Logger logger = Logger.getLogger(GraphExport.class);
         public GraphExport(Graph graph) {
             logger.trace("ENTRY");
             this.vertices = new ArrayList<>(graph.getVertices().values());
             this.edges = new ArrayList<>(graph.getEdges());
             this.vertexArchetypes = new ArrayList<>(graph.getVertexArchetypes());
             this.edgeArchetypes = new ArrayList<>(graph.getEdgeArchetypes());
             this.attributeTypes = new ArrayList<>(graph.getAttributeTypes());
             this.possibleEnumValues = graph.getPossibleEnumValues();
             this.archetypeIcons = graph.getArchetypeIcons();
             this.groups = graph.getGraphState().getGroups();
             this.positions = graph.getGraphState().getPositions();
             this.sideBar = graph.getGraphState().getSideBar();
             this.selectedVertex = graph.getGraphState().getSelectedVertex();
             this.selectedEdge = graph.getGraphState().getSelectedEdge();
             logger.trace("EXIT");
+        }
         public List<Edge> getEdges() {
             logger.trace("ENTRY");
             logger.trace("EXIT");
             return edges;
+        }
         public List<Vertex> getVertices() {
             logger.trace("ENTRY");
             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<Group> getGroups() {
             return groups;
+        }
         public List<Position> getPositions() {
             return positions;
+        }
         public List<SideBar> getSideBar() {
             return sideBar;
+        }
         public int getSelectedVertex() {
             return selectedVertex;
+        }
         public int getSelectedEdge() {
             return selectedEdge;
+        }
+    }

     package cz.zcu.kiv.offscreen.api;
     import java.util.ArrayList;
     import java.util.List;
     /**
      * Class represents group of edges and their settings. Used in JSON between frontend and backend.
      */
     public class Group {
         /** Generated id of group which is unique only in groups. */
         private int groupId;
         /** Generated if of group which is unique in groups and vertexes. */
         private int id;
         /** Name of group */
         private String name;
         /** List of vertices id which belongs to this group */
         private List<Integer> verticesId;
         /** List of vertices id whose outgoing edges are visible. */
         private List<Integer> verticesEdgeFromId;
         /** List of vertices id whose incoming edges are visible. */
         private List<Integer> verticesEdgeToId;
         public Group(int groupId, int id, String name){
             this.groupId = groupId;
             this.id = id;
             this.name = name;
             verticesId = new ArrayList<>();
             verticesEdgeFromId = new ArrayList<>();
             verticesEdgeToId = new ArrayList<>();
+        }
         public Group(int groupId, int id, String name, List<Integer> verticesId, List<Integer> verticesEdgeFromId, List<Integer> verticesEdgeToId) {
             this.groupId = groupId;
             this.id = id;
             this.name = name;
             this.verticesId = verticesId;
             this.verticesEdgeFromId = verticesEdgeFromId;
             this.verticesEdgeToId = verticesEdgeToId;
+        }
         public int getGroupId() {
             return groupId;
+        }
         public void setGroupId(int groupId) {
             this.groupId = groupId;
+        }
         public int getId() {
             return id;
+        }
         public void setId(int id) {
             this.id = id;
+        }
         public String getName() {
             return name;
+        }
         public void setName(String name) {
             this.name = name;
+        }
         public List<Integer> getVerticesId() {
             return verticesId;
+        }
         public void setVerticesId(List<Integer> verticesId) {
             this.verticesId = verticesId;
+        }
         public List<Integer> getVerticesEdgeFromId() {
             return verticesEdgeFromId;
+        }
         public void setVerticesEdgeFromId(List<Integer> verticesEdgeFromId) {
             this.verticesEdgeFromId = verticesEdgeFromId;
+        }
         public List<Integer> getVerticesEdgeToId() {
             return verticesEdgeToId;
+        }
         public void setVerticesEdgeToId(List<Integer> verticesEdgeToId) {
             this.verticesEdgeToId = verticesEdgeToId;
+        }
         public void addVertexId(int vertexId){
             this.verticesId.add(vertexId);
+        }
         public void addVetexEdgeToId(int vertexId){
             this.verticesEdgeToId.add(vertexId);
+        }
         public void addVetexEdgeFromId(int vertexId){
             this.verticesEdgeFromId.add(vertexId);
+        }
+    }

     package cz.zcu.kiv.offscreen.api;
     /**
      * Class is used for storing information about vertex/group relative position.
      */
     public class Position {
         /** Identification number of vertex or group which was generated in application. */
         private int vertexId;
         /** Relative X position. */
         private float x;
         /** Relative Y position */
         private float y;
         public Position(int vertexId, float x, float y) {
             this.vertexId = vertexId;
             this.x = x;
             this.y = y;
+        }
         public int getVertexId() {
             return vertexId;
+        }
         public void setVertexId(int vertexId) {
             this.vertexId = vertexId;
+        }
         public float getX() {
             return x;
+        }
         public void setX(float x) {
             this.x = x;
+        }
         public float getY() {
             return y;
+        }
         public void setY(float y) {
             this.y = y;
+        }
+    }

     package cz.zcu.kiv.offscreen.api;
     /**
      * Class store information about item in side bar.
      */
     public class SideBar {
         /** Identification number of vertex or group which was generated in application. */
         private int vertexId;
         /** Indicates if related vertexes of this item have visible icon which shows relation with this item. */
         private boolean highlighted;
         public SideBar(int vertexId, boolean highlighted) {
             this.vertexId = vertexId;
             this.highlighted = highlighted;
+        }
         public int getVertexId() {
             return vertexId;
+        }
         public void setVertexId(int vertexId) {
             this.vertexId = vertexId;
+        }
         public boolean isHighlighted() {
             return highlighted;
+        }
         public void setHighlighted(boolean highlighted) {
             this.highlighted = highlighted;
+        }
+    }

     package cz.zcu.kiv.offscreen.api;
     import java.util.List;
     public class SubedgeInfo {
         /** Edge archetype index. */
         private int archetype;
         /** Original id of edge which is taken from input JSON file. */
         private int originalId;
         /** List of all tributes. Every attribute is stored in String array in pair as {attribute name, attribute value}. */
         private List<String[]> attributes;
         /**
          * Create new subedgeInfo
          * @param originalId Original id of edge which is taken from input JSON file.
          * @param archetype Edge archetype index.
          * @param attributes  List of all tributes. Every attribute is stored in String array in pair as {attribute name, attribute value}.
          */
         public SubedgeInfo(int originalId, int archetype, List<String[]> attributes) {
             this.originalId = originalId;
             this.archetype = archetype;
             this.attributes = attributes;
+        }
         public int getOriginalId() {
             return originalId;
+        }
         public int getArchetype() {
             return archetype;
+        }
         public List<String[]> getAttributes() {
             return attributes;
+        }
+    }

     package cz.zcu.kiv.offscreen.api;
     import java.util.List;
     /**
      * Class represents vertex which is used for output JSON format (JSON between frontend and backend)
      */
     public class Vertex extends BaseVertex {
         /** List of all tributes. Every attribute is stored in String array in pair as {attribute name, attribute value}. */
         private List<String[]> attributes;
         /**
          * Create new vertex.
          * @param id new generated identification number.
          * @param originalId original identification number from input file
          * @param title title of vertex
          * @param archetypeIndex index of vertex archetype
          * @param text additional info
          * @param attributes List of all attributes. Every attribute is stored in String array in pair as {attribute name, attribute value}.
          */
         public Vertex(int id, int originalId, String title, int archetypeIndex, String text, List<String[]> attributes) {
             super(id, originalId, title, archetypeIndex, text);
             this.attributes = attributes;
+        }
         public List<String[]> getAttributes() {
             return attributes;
+        }
         public void setAttributes(List<String[]> attributes) {
             this.attributes = attributes;
+        }
+    }

     ///**
     // *
     // */
     //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 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.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.graph;
     /**
      * This class represents attribute of edge or vertex.
      */
     public class Attribute {
         /** Index to array of attribute types which is defined in input JSON file */
         private int typeIndex;
         /** Value of attribute */
         private Object value;
         public Attribute(int typeIndex, Object value) {
             this.typeIndex = typeIndex;
             this.value = value;
+        }
         public int getTypeIndex() {
             return typeIndex;
+        }
         public void setTypeIndex(int typeIndex) {
             this.typeIndex = typeIndex;
+        }
         public Object getValue() {
             return value;
+        }
         public void setValue(Object value) {
             this.value = value;
+        }
+    }

     package cz.zcu.kiv.offscreen.graph;
     /**
      * Class represents one attribute type which is used in input JSON file and in output JSON file (file between frontend
      * and backend).
      */
     public class AttributeType {
         /** name of attribute */
         public String name;
         /** data type of attribute */
         public GraphManager.AttributeDataType dataType;
         /** additional info */
         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;
+        }
         public String getText() {
             return text;
+        }
+    }

     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;
+        }
         public String getText() {
             return text;
+        }
+    }

     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 cz.zcu.kiv.offscreen.api.BaseEdge;
     import java.util.*;
     /**
      * Class represents edge which is used for input JSON format.
      */
     public class EdgeImpl extends BaseEdge {
         /** original identification number which is defined in input file */
         private int originalId;
         /** index of edge archetype */
         private int archetypeIndex;
         /** Map contains attributes stored in key value format. Key is index to array of attribute types defined in input file */
         private Map<Integer, Attribute> attributesMap;
         /**
          * Create new edge.
          * @param id new generated identification number
          * @param from original ID of vertex from edge leads
          * @param to original ID of vertex where edge leads
          * @param text additional info
          * @param originalId original identification number which is defined in input file
          * @param archetypeIndex index of edge archetype
          */
         public EdgeImpl(int id, int from, int to, String text, int originalId, int archetypeIndex) {
             super(id, from, to, text);
             this.originalId = originalId;
             this.archetypeIndex = archetypeIndex;
             this.attributesMap = new HashMap<>();
+        }
         public Attribute getAttribute(int attrTypeIndex) {
             return attributesMap.get(attrTypeIndex);
+        }
         public Map<Integer, Attribute> getAttributesMap() {
             return attributesMap;
+        }
         public int getOriginalId() {
             return originalId;
+        }
         public int getArchetype() {
             return archetypeIndex;
+        }
         public void addAttribute(int attrTypeIndex, Object value) {
             Attribute attr = new Attribute(attrTypeIndex, value);
             attributesMap.put(attrTypeIndex, attr);
+        }
         public void addAttributes(Map<Integer, Attribute> attributes) {
             this.attributesMap.putAll(attributes);
+        }
         public void setOriginalId(int originalId) {
             this.originalId = originalId;
+        }
         public void setArchetypeIndex(int archetypeIndex) {
             this.archetypeIndex = archetypeIndex;
+        }
         /**
          * Return list of attributes sorted by their key value in {@code attributeMap}
          * @return sorted list
          */
         public List<Attribute> getSortedAttributes() {
             List<Attribute> list = new ArrayList<>();
             ArrayList<Integer> indices = new ArrayList<>(attributesMap.keySet());
             //indices.sort(Integer::compareTo);
             Collections.sort(indices);
             for (Integer index : indices) {
                 list.add(attributesMap.get(index));
+            }
             return list;
+        }
+    }

     package cz.zcu.kiv.offscreen.graph;
     import cz.zcu.kiv.offscreen.api.Edge;
     import cz.zcu.kiv.offscreen.api.Vertex;
     import org.apache.log4j.Logger;
     import java.util.HashMap;
     import java.util.LinkedList;
     import java.util.List;
     import java.util.Map;
     /**
      * Class represents graph which is loaded from input JSON file.
      */
     public class Graph {
         private Map<String, Vertex> vertices;
         private List<Edge> edges;
         private List<VertexArchetype> vertexArchetypes;
         private List<EdgeArchetype> edgeArchetypes;
         private List<AttributeType> attributeTypes;
         private Map<String, List<String>> possibleEnumValues;
         private List<String> defaultGroupArchetypes;
         private Map<String, String> archetypeIcons;
         private GraphState graphState;
         private Logger logger = Logger.getLogger(Graph.class);
         public Graph() {
             logger.trace("ENTRY");
             this.vertices = new HashMap<String, Vertex>();
             this.edges = new LinkedList<Edge>();
             logger.trace("EXIT");
+        }
         public List<Edge> getEdges() {
             logger.trace("ENTRY");
             logger.trace("EXIT");
             return edges;
+        }
         public List<VertexArchetype> getVertexArchetypes() {
             return vertexArchetypes;
+        }
         public List<EdgeArchetype> getEdgeArchetypes() {
             return edgeArchetypes;
+        }
         public void setVertexArchetypes(List<VertexArchetype> vertexArchetypes) {
             this.vertexArchetypes = vertexArchetypes;
+        }
         public  void setEdgeArchetypes(List<EdgeArchetype> edgeArchetypes) {
             this.edgeArchetypes = edgeArchetypes;
+        }
         public void setAttributeTypes(List<AttributeType> attributeTypes) {
             this.attributeTypes = attributeTypes;
+        }
         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;
+        }
         public List<String> getDefaultGroupArchetypes() {
             return defaultGroupArchetypes;
+        }
         public void setDefaultGroupArchetypes(List<String> defaultGroupArchetypes) {
             this.defaultGroupArchetypes = defaultGroupArchetypes;
+        }
         public List<AttributeType> getAttributeTypes() {
             return attributeTypes;
+        }
         public Map<String, List<String>> getPossibleEnumValues() {
             return possibleEnumValues;
+        }
         public Map<String, String> getArchetypeIcons() {
             return archetypeIcons;
+        }
         public Map<String, Vertex> getVertices() {
             logger.trace("ENTRY");
             logger.trace("EXIT");
             return vertices;
+        }
         public void addEdge(Edge edge) {
             logger.trace("ENTRY");
             this.edges.add(edge);
             logger.trace("EXIT");
+        }
         public void addVertex(String name, Vertex vertex) {
             logger.trace("ENTRY");
             this.vertices.put(name, vertex);
             logger.trace("EXIT");
+        }
         public GraphState getGraphState() {
             return graphState;
+        }
         public void setGraphState(GraphState graphState) {
             this.graphState = graphState;
+        }
+    }

     package cz.zcu.kiv.offscreen.graph;
     import cz.zcu.kiv.offscreen.api.Edge;
     import cz.zcu.kiv.offscreen.api.Group;
     import cz.zcu.kiv.offscreen.api.SubedgeInfo;
     import cz.zcu.kiv.offscreen.api.Vertex;
     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";
+                }
+            }
+        }
         private int lastVertexOrGroupId = 1;
         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<VertexImpl>> 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<EdgeImpl>> 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));
+        }
         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;

Projekt

Obecné

Profil

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

Revize fa634b08

Přidáno uživatelem Pavel Fidranský před více než 6 roky(ů)