/** Builds the set of paths between all the couple of vertexes */
private void buildPaths() {
logger.debug("IN");
allGraphPaths = new HashSet<GraphPath<IModelEntity, Relationship>>();
paths = new HashSet<EntitiesPath>();
// build all the path between entities
Iterator<IModelEntity> vertexesIter = entities.iterator();
// First loop for the source of the path
while (vertexesIter.hasNext()) {
IModelEntity startVertex = vertexesIter.next();
logger.debug("Building the list of path starting from " + startVertex.getName());
// inner loop for the target of the path
Iterator<IModelEntity> vertexesInnerIter = entities.iterator();
while (vertexesInnerIter.hasNext()) {
IModelEntity endVertex = vertexesInnerIter.next();
if (!startVertex.equals(endVertex)) {
EntitiesPath entitiesPath = new EntitiesPath(startVertex, endVertex);
if (!this.paths.contains(entitiesPath)) {
logger.debug(
"Building the list of path between the vertexes ["
+ startVertex.getName()
+ ","
+ endVertex.getName()
+ "]");
KShortestPaths<IModelEntity, Relationship> kshortestPath =
new KShortestPaths<IModelEntity, Relationship>(graph, startVertex, maxPathLength);
List<GraphPath<IModelEntity, Relationship>> graphPaths =
kshortestPath.getPaths(endVertex);
// if there is at least one path between the 2 vertex
if (graphPaths != null) {
entitiesPath.setPaths(graphPaths);
// updating the class variables
this.paths.add(entitiesPath);
for (int i = 0; i < graphPaths.size(); i++) {
GraphPath<IModelEntity, Relationship> path = graphPaths.get(i);
if (!containsPath(this.allGraphPaths, path)) {
this.allGraphPaths.add(path);
}
}
}
}
}
}
}
logger.debug("OUT");
}
/**
* gets the ambiguous paths: we have an ambiguous path where there is more than one path that
* connects two entities.
*
* @return the ambiguous paths. If there is no ambiguous path the set is empty
*/
private Set<EntitiesPath> getAmbiguousEntitiesPaths() {
logger.debug("IN: finding the ambiguous paths");
Set<EntitiesPath> ambiguouPaths = new HashSet<EntitiesPath>();
if (paths != null) {
logger.debug("Checking if there is more than one path between all the connected entities");
Iterator<EntitiesPath> iter = paths.iterator();
while (iter.hasNext()) {
EntitiesPath path = iter.next();
if (path.getPaths() != null && path.getPaths().size() > 1) {
ambiguouPaths.add(path);
}
}
}
logger.debug("OUT");
return ambiguouPaths;
}
/**
* Gets the map where the key are ambiguous Entities and the values are all the paths that pass
* through the ambiguous entities
*
* @return
*/
public Map<IModelEntity, Set<GraphPath<IModelEntity, Relationship>>>
getAmbiguousEntitiesAllPathsMap() {
logger.debug("IN");
Map<IModelEntity, Set<GraphPath<IModelEntity, Relationship>>> ambiguouPathsMap =
new HashMap<IModelEntity, Set<GraphPath<IModelEntity, Relationship>>>();
Set<EntitiesPath> ambiguouPaths = getAmbiguousEntitiesPaths();
if (ambiguouPaths != null) {
Iterator<EntitiesPath> iter = ambiguouPaths.iterator();
// add the paths to the ambiguous path map
while (iter.hasNext()) {
EntitiesPath entitiesPath = iter.next();
Set<GraphPath<IModelEntity, Relationship>> pathsInvolvingStartEntity;
if (!ambiguouPathsMap.containsKey(entitiesPath.getEndPoints().get(0))) {
pathsInvolvingStartEntity =
getPathsOfAmbigousEntities(entitiesPath.getEndPoints().get(0));
ambiguouPathsMap.put(entitiesPath.getEndPoints().get(0), pathsInvolvingStartEntity);
}
Set<GraphPath<IModelEntity, Relationship>> pathsInvolvingEndEntity;
if (!ambiguouPathsMap.containsKey(entitiesPath.getEndPoints().get(1))) {
pathsInvolvingEndEntity = getPathsOfAmbigousEntities(entitiesPath.getEndPoints().get(1));
ambiguouPathsMap.put(entitiesPath.getEndPoints().get(1), pathsInvolvingEndEntity);
}
}
}
logger.debug("OUT");
return ambiguouPathsMap;
}
