Updated API and API documentation
The recent changes in the API made an update necessary. At the same
time, the documentation needed to be updated to make the contracts
for the different methods in key interfaces clearer.
This patch addresses both issues by removing superfluous methods,
simplifying method signatures, and providing clearer definitions of
the method contracts that reflect the API evolution.
Change-Id: Icf99a4ca4784e39376c4be65b770133d9d413957
diff --git a/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/AbstractMetaModelAdapter.java b/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/AbstractMetaModelAdapter.java
index 647a13b..8930b37 100644
--- a/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/AbstractMetaModelAdapter.java
+++ b/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/AbstractMetaModelAdapter.java
@@ -25,7 +25,8 @@
/**
* Implements standard functionality for the methods defined in the
- * {@link TraceMetaModelAdapter}.
+ * {@link TraceMetaModelAdapter}, in particular to delegate retrieving internal
+ * links to the respective handler.
*/
public abstract class AbstractMetaModelAdapter implements TraceMetaModelAdapter {
@@ -52,39 +53,29 @@
return allElements;
}
- /**
- * Used to get internal links connected to a selected element.
- *
- * @param element the selected element
- * @param traceModel the current trace model
- * @param selectedRelationshipTypes the selected relationship types from the
- * filter, if the user has selected any
- * @param maximumDepth The maximum depth the transitivity should
- * go. 0 means show all the links
- * @param existingTraces The trace links that have been created
- * manually by the user, these are obtained
- * from the trace model
- */
@Override
public List<Connection> getInternalElementsTransitive(EObject element, EObject traceModel,
- List<String> selectedRelationshipTypes, int maximumDepth, List<Connection> existingTraces) {
+ List<String> traceLinkTypes, int maximumDepth) {
List<Object> accumulator = new ArrayList<>();
- return getInternalElementsTransitive(element, traceModel, accumulator, selectedRelationshipTypes, 0,
- maximumDepth, existingTraces);
+ List<Connection> existingTraces = new ArrayList<>();
+ return getInternalElementsTransitive(element, traceModel, accumulator, traceLinkTypes, 0, maximumDepth,
+ existingTraces);
+ }
+
+ @Override
+ public List<Connection> getInternalElements(EObject element, EObject traceModel, List<String> traceLinkTypes) {
+ return getInternalElements(element, traceModel, traceLinkTypes, false, 0, new ArrayList<>());
}
@SuppressWarnings("unchecked")
- @Override
- public List<Connection> getInternalElements(EObject element, EObject traceModel,
- List<String> selectedRelationshipTypes, boolean traceLinksTransitive, int transitivityDepth,
- List<Connection> existingTraces) {
+ private List<Connection> getInternalElements(EObject element, EObject traceModel, List<String> traceLinkTypes,
+ boolean traceLinksTransitive, int transitivityDepth, List<Connection> existingTraces) {
List<Connection> allElements = new ArrayList<>();
List<Connection> directElements;
if (traceLinksTransitive) {
- directElements = getTransitivelyConnectedElements(element, traceModel, selectedRelationshipTypes,
- transitivityDepth);
+ directElements = getTransitivelyConnectedElements(element, traceModel, traceLinkTypes, transitivityDepth);
} else {
- directElements = getConnectedElements(element, traceModel, selectedRelationshipTypes);
+ directElements = getConnectedElements(element, traceModel, traceLinkTypes);
}
List<Integer> hashCodes = new ArrayList<>();
@@ -100,12 +91,13 @@
if (!hashCodes.contains(conn.hashCode())) {
allElements.add(conn);
}
+
// get internal links from source
for (EObject o : conn.getOrigins()) {
Object origin = artifactHelper.unwrapWrapper(o);
IArtifactHandler<?> originHandler = artifactHelper.getHandler(origin).get();
if (originHandler != null) {
- allElements.addAll(originHandler.addInternalLinks(o, selectedRelationshipTypes));
+ allElements.addAll(originHandler.getInternalLinks(o, traceLinkTypes));
}
}
// get internal links from targets
@@ -113,7 +105,7 @@
Object originalObject = artifactHelper.unwrapWrapper(o);
IArtifactHandler<?> handler = artifactHelper.getHandler(originalObject).orElseThrow();
if (handler != null) {
- allElements.addAll(handler.addInternalLinks(o, selectedRelationshipTypes));
+ allElements.addAll(handler.getInternalLinks(o, traceLinkTypes));
}
}
}
@@ -122,7 +114,7 @@
Object originalObject = artifactHelper.unwrapWrapper(element);
IArtifactHandler<?> handler = artifactHelper.getHandler(originalObject).orElseThrow();
if (handler != null) {
- allElements.addAll(handler.addInternalLinks(element, selectedRelationshipTypes));
+ allElements.addAll(handler.getInternalLinks(element, traceLinkTypes));
}
}
@@ -130,7 +122,7 @@
if (element.getClass().getPackage().toString().contains("org.eclipse.eatop")) {
IArtifactHandler<Object> handler = (IArtifactHandler<Object>) artifactHelper.getHandler(element)
.orElseThrow();
- allElements.addAll(handler.addInternalLinks(element, selectedRelationshipTypes));
+ allElements.addAll(handler.getInternalLinks(element, traceLinkTypes));
}
return allElements;
}
diff --git a/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/ArtifactMetaModelAdapter.java b/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/ArtifactMetaModelAdapter.java
index 6f2e640..f8e06b2 100644
--- a/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/ArtifactMetaModelAdapter.java
+++ b/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/ArtifactMetaModelAdapter.java
@@ -22,6 +22,17 @@
/**
* This interface defines the functionality necessary to deal with meta models
* that describe the artifacts to and from which trace links are created.
+ *
+ * An artifact model is used to capture all wrappers, i.e., {@link EObject}
+ * instances that describe artifacts that are not themselves {@code EObject}
+ * instances. Since Eclipse Capra uses EMF internally to represent links,
+ * artifacts, etc. all artifacts that are either the origin or the source of a
+ * link need to be represented as {@code EObject}s as well. This means that
+ * artifacts for which this is not true need to have a "wrapper" that
+ * contains the relevant information about these artifacts such as their names
+ * and URIs. These wrappers are stored in an artifact model and the structure of
+ * this artifact model is in turn described by an artifact meta-model. This
+ * class provides access to the wrappers via the artifact model.
*/
public interface ArtifactMetaModelAdapter {
@@ -33,36 +44,50 @@
EObject createModel();
/**
- * TODO: The implementation of this method delegates to the other methods
- * with the same name. It exists to enables implementing objects to work
- * with both the old and the new API during a transmission period.
+ * Create a new artifact. The list of artifacts is searched for an existing
+ * artifact with the same handler and URI. If found, the existing artifact is
+ * returned, otherwise a new artifact is created.
+ *
+ * TODO: The implementation of this method delegates to the other methods with
+ * the same name. It exists to enable implementing objects to work with both the
+ * old and the new API during a transition period. This implementation uses the
+ * artifacts URI as its unique identifier.
+ *
+ * @param artifactModel
+ * @param artifactHandler
+ * @param artifactUri
+ * @param artifactId
+ * @param artifactName
+ * @param artifactFilePath
+ * @return
*/
- default EObject createArtifact(EObject artifactModel, String artifactHandler, String artifactUri,
- String artifactName, String artifactFilePath) {
+ default EObject createArtifact(EObject artifactModel, String artifactHandler, String artifactUri,
+ String artifactName, String artifactFilePath) {
return createArtifact(artifactModel, artifactHandler, artifactUri, artifactUri, artifactName, artifactFilePath);
}
/**
* Create a new artifact. The list of artifacts is searched for an existing
- * artifact with the same handler and URI. If found, the existing artifact
- * is returned, otherwise a new artifact is created.
- * <p/>
- * TODO: The implementation of this method delegates to the other methods
- * with the same name. It exists to enables implementing objects to work
- * with both the old and the new API during a transmission period.
+ * artifact with the same handler and URI. If found, the existing artifact is
+ * returned, otherwise a new artifact is created.
+ *
+ * @param artifactModel the artifact model to add the artifact to
+ * @param artifactHandler the handler responsible for dealing with the artifact
+ * @param artifactUri the URI of the artifact
+ * @param artifactId the unique identifier of the artifact
+ * @param artifactName the name of the artifact
+ * @param artifactFilePath the file path to the artifact
+ * @return a newly created artifact or an existing artifact with the same
+ * handler and URI
*/
- default EObject createArtifact(EObject artifactModel, String artifactHandler, String artifactUri,
- String artifactId, String artifactName, String artifactFilePath) {
- return createArtifact(artifactModel, artifactHandler, artifactId, artifactName, artifactFilePath);
- }
+ EObject createArtifact(EObject artifactModel, String artifactHandler, String artifactUri, String artifactId,
+ String artifactName, String artifactFilePath);
/**
- * Get artifact with given handler and URI.
+ * Gets the artifact with the given handler and URI.
*
- * @param artifactHandler
- * Handler of artifact
- * @param artifactUri
- * URI of artifact
+ * @param artifactHandler Handler of artifact
+ * @param artifactUri URI of artifact
* @return artifact if found, null otherwise
*/
EObject getArtifact(EObject artifactModel, String artifactHandler, String artifactUri);
@@ -85,16 +110,18 @@
/**
* Get the URI of the given artifact. The URI be a string with a valid URI
- * syntax.
+ * syntax.
* <p/>
- * The path part should refer to a concrete resource, such as a
- * file or a web page.
+ * The path part should refer to a concrete resource, such as a file or a web
+ * page.
* <p/>
- * The fragment part should (if necessary) uniquely
- * identify the artifact within the resource. It can consists of a sequence of sub-parts separated '/'. In that
- * way tools that work with artifacts can used the sub-parts of the fragment for their own purposes.
+ * The fragment part should (if necessary) uniquely identify the artifact within
+ * the resource. It can consists of a sequence of sub-parts separated '/'. In
+ * that way tools that work with artifacts can used the sub-parts of the
+ * fragment for their own purposes.
* <p/>
- * Example: The JDT artifact handler uses the following encoding scheme for artifact URI:s:
+ * Example: The JDT artifact handler uses the following encoding scheme for
+ * artifact URI:s:
* {@code platform:/Project_name/path/to/file.java#com.pack.ClassName/methodName(int, String)}.
*
* @param artifact
@@ -103,12 +130,13 @@
String getArtifactUri(EObject artifact);
/**
- * @return An internal string that handlers use to locate and reconstruct the artifact.
+ * @return An internal string that handlers use to locate and reconstruct the
+ * artifact.
*/
default String getArtifactIdentifier(EObject artifact) {
return getArtifactUri(artifact);
}
-
+
/**
* Get the path of the given artifact.
*
diff --git a/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/Connection.java b/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/Connection.java
index 7c3dd5b..1c872ca 100644
--- a/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/Connection.java
+++ b/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/Connection.java
@@ -32,20 +32,44 @@
private List<EObject> targets;
private EObject tlink;
+ /**
+ * Constructs a new {@code Connection} instance based on the provided origins,
+ * targets, and underlying trace link.
+ *
+ * @param origins the origins, i.e., the artifacts from which the link
+ * originates
+ * @param targets the targets, i.e., the artifacts to which the link points
+ * @param tlink the underlying trace link from the trace model
+ */
public Connection(List<EObject> origins, List<EObject> targets, EObject tlink) {
this.origins = origins;
this.targets = targets;
this.tlink = tlink;
}
+ /**
+ * Get all origins, i.e., artifacts from which the trace link originates.
+ *
+ * @return the origins
+ */
public List<EObject> getOrigins() {
return origins;
}
+ /**
+ * Get all targets, i.e., artifacts to which the trace link points.
+ *
+ * @return the targets
+ */
public List<EObject> getTargets() {
return targets;
}
+ /**
+ * Gets the underlying trace link from the trace model.
+ *
+ * @return the trace link which this {@code Connection} instance represents
+ */
public EObject getTlink() {
return tlink;
}
diff --git a/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/TraceMetaModelAdapter.java b/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/TraceMetaModelAdapter.java
index b91a0c5..894ac04 100644
--- a/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/TraceMetaModelAdapter.java
+++ b/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/TraceMetaModelAdapter.java
@@ -22,7 +22,26 @@
/**
* This interface defines all functionality that must be implemented to support
* a specific trace metamodel. This enables swapping the concept of what a
- * "trace" is, as long as these methods can be implemented.
+ * "trace" is, as long as these methods can be implemented.
+ *
+ * Important concepts:
+ * <ul>
+ * <li>Trace type: A trace link always has a specific type that is designated by
+ * a name (e.g., "Related to" or "Implemented by"), the type of artifacts it
+ * connects, and the number of artifacts that can be connected (e.g., one origin
+ * artifact can be connected to several target artifacts).</li>
+ * <li>Origin and Target: In general, a trace link is directed, i.e., it
+ * connects one or more origin artifacts to one or more source artifacts.</li>
+ * <li>Transitivity: Consider to trace links A->B and B->C. A and B as well as B
+ * and C are directly connected. A and C, however, are transitively connected,
+ * meaning that the connection between these elements goes via another
+ * element.</li>
+ * <li>Internal links: Many DSLs already contain relationships as part of the
+ * constructs they support. UML, e.g., supports relationships such as
+ * associations, generalisation, messages, etc. Eclipse Capra can make use of
+ * such "internal links". Which relationships are exposed to Eclipse
+ * Capra in this way is determined by the respective handler.
+ * </ul>
*
* @author Anthony Anjorin, Salome Maro
*
@@ -30,7 +49,7 @@
public interface TraceMetaModelAdapter {
/**
- * Create a new model for the trace links.
+ * Create a new model for trace links.
*
* @return the new trace model
*/
@@ -38,114 +57,140 @@
EObject createModel();
/**
- * Used to retrieve a set of types of traces that can be created for the given
- * selection of objects in the Eclipse workspace
+ * Used to retrieve a set of trace types that can be created for the given
+ * objects. This method does not differentiate between origin and target.
+ * Implementing classes need to ensure that this distinction is either ignored
+ * or ensure that the correct origin are determined from the provided list
+ * (e.g., by using the first list entry as the source).
*
- * @param selection The selection of objects the user has made and wants to
- * create a trace for in the Eclipse workspace
+ * @param selection the objects for which the available trace types should be
+ * retrieved
* @return A collection of possible types of traces that can be created for the
- * given selection
+ * given objects
*/
Collection<EClass> getAvailableTraceTypes(List<EObject> selection);
/**
- * Used to create a trace of the given type
+ * Used to create a trace of the given type.
*
- * @param traceType The type of the trace to be created
- * @param traceModel The root of the trace model that should contain the trace
- * type. If this is empty, then a new root is to be created
- * and returned.
- * @param selection Objects to create the trace for
+ * @param traceType the type of the trace to be created
+ * @param traceModel the root of the trace model that should contain the trace
+ * type. If {@code null}, a new root is created and returned.
+ * @param origins the origin artifacts for this trace link
+ * @param targets the target artifacts for this trace link
* @return the trace link that has just been created
*/
EObject createTrace(EClass traceType, EObject traceModel, List<EObject> origins, List<EObject> targets);
/**
- * Decide if two objects are connected according to the given trace model
+ * Decide if two objects are connected according to the given trace model. This
+ * means that all traces in the trace model are checked and {@code true} is
+ * returned if and only if the trace model contains a trace link that connects
+ * the {@code origin} to the {@code target}.
*
- * @param first First object
- * @param second Second object
- * @param traceModel Trace model to base decision on
- * @return <code>true</code> if object are connected, <code>false</code>
+ * @param origin First object
+ * @param target Second object
+ * @param traceModel trace model to base decision on
+ * @return <code>true</code> if the artifacts are connected, <code>false</code>
* otherwise
*/
- boolean isThereATraceBetween(EObject first, EObject second, EObject traceModel);
+ boolean isThereATraceBetween(EObject origin, EObject target, EObject traceModel);
/**
- * Determine a list of all objects connected to element according to the given
- * trace model
+ * Determine a list of all objects connected to {@code element} according to the
+ * given trace model.
*
- * @param element The element used to determine the list of connected
- * objects. Note that this element could be a trace in the
- * trace model
- * @param traceModel Trace model to base calculation on
- * @return A Map with the following structure: [Trace object t -> {list of all
- * objects connected to element via t}]
+ * There are two ways {@code element} can be used:
+ * <ol>
+ * <li>If {@code element} is an arbitrary {@link EObject}, then the method
+ * returns all trace links in which {@code element} is one of the origins.</li>
+ * <li>If {@code element} is a trace link, then the method returns a
+ * representation of the trace link itself.</li>
+ * </ol>
+ *
+ * @param element the element used to determine the list of connected
+ * objects.
+ * @param traceModel the trace model to base calculation on
+ * @return a list of {@link Connection}s from the provided {@code traceModel}
+ * that contain {@code element} as one of their origins or a
+ * representation of {@code element} if {@code element} is a trace link
*/
List<Connection> getConnectedElements(EObject element, EObject traceModel);
/**
- * Determine a list of all objects connected to element according to the given
- * trace model
+ * Determine a list of all objects connected to {@code element} according to the
+ * given trace model based on the provided list of trace link types. If
+ * {@code selectedRelationshipTypes} is empty or {@code null}, this method
+ * behaves exactly like {@link #getConnectedElements(EObject, EObject)}.
*
- * @param element The element used to determine the list of
- * connected objects. Note that this element
- * could be a trace in the trace model
- * @param traceModel Trace model to base calculation on
- * @param selectedRelationshipTypes List of selected relationship types from the
- * context menu of plantuml
- * @return A Map with the following structure: [Trace object t -> {list of all
- * objects connected to element via t}]
+ * @param element the element used to determine the list of connected
+ * objects.
+ * @param traceModel the trace model to base calculation on
+ * @param traceLinkTypes a list of permissible trace link types (may be
+ * {@code null} or empty)
+ * @return a list of {@link Connection}s from the provided {@code traceModel}
+ * that contain {@code element} as one of their origins or a
+ * representation of {@code element} if {@code element} is a trace link
*/
- List<Connection> getConnectedElements(EObject element, EObject traceModel, List<String> selectedRelationshipTypes);
+ List<Connection> getConnectedElements(EObject element, EObject traceModel, List<String> traceLinkTypes);
/**
- * Determine a list of all objects connected to element according to the given
- * trace model
+ * Determine a list of all objects transitively connected to {@code element}
+ * according to the given trace model.
+ * <p>
+ * This means that if a trace model contains a link A->B and a link B->C, this
+ * method will return the two connections representing this link if
+ * {@code transitivityDepth} is either 0 or greater than 1. If the trace model
+ * does not contain any transitive links of this sort or the
+ * {@code transitivityDepth} is set to 1, this method should behave exactly like
+ * {@link #getConnectedElements(EObject, EObject, List)}.
*
* @param element The element used to determine the list of connected
* objects. Note that this element could be a trace in
- * the trace model
+ * the trace model.
* @param traceModel Trace model to base calculation on
- * @param transitivityDepth The maximum depth the user wants to go down
- * transitively. 0 indicates no limit.
- * @return A Map with the following structure: [Trace object t -> {list of all
- * objects connected to element via t}]
+ * @param transitivityDepth The maximum depth of the transitive closure.
+ * {@code 0} means that no limit is applied.
+ * @return a list of {@link Connection}s from the provided {@code traceModel}
+ * that contain {@code element} as one of their origins or a
+ * representation of {@code element} if {@code element} is a trace link
*/
List<Connection> getTransitivelyConnectedElements(EObject element, EObject traceModel, int transitivityDepth);
/**
- * Determine a list of all objects connected to element according to the given
- * trace model
+ * Determine a list of all objects transitively connected to {@code element}
+ * according to the given trace model based on the provided list of trace link
+ * types. If {@code selectedRelationshipTypes} is empty or {@code null}, this
+ * method behaves exactly like
+ * {@link #getTransitivelyConnectedElements(EObject, EObject, int)}.
*
- * @param element The element used to determine the list of
- * connected objects. Note that this element
- * could be a trace in the trace model
- * @param traceModel Trace model to base calculation on
- * @param selectedRelationshipTypes List of selected relationship types from the
- * context menu of plantuml
- * @param transitivityDepth The maximum depth the user wants to go down
- * transitively. 0 indicates no limit.
- * @return A Map with the following structure: [Trace object t -> {list of all
- * objects connected to element via t}]
+ * @param element the element used to determine the list of connected
+ * objects.
+ * @param traceModel trace model to base calculation on
+ * @param traceLinkTypes a list of permissible trace link types (may be
+ * {@code null} or empty)
+ * @param transitivityDepth The maximum depth of the transitive closure.
+ * {@code 0} means that no limit is applied.
+ * @return a list of {@link Connection}s from the provided {@code traceModel}
+ * that contain {@code element} as one of their origins or a
+ * representation of {@code element} if {@code element} is a trace link
*/
- List<Connection> getTransitivelyConnectedElements(EObject element, EObject traceModel,
- List<String> selectedRelationshipTypes, int transitivityDepth);
+ List<Connection> getTransitivelyConnectedElements(EObject element, EObject traceModel, List<String> traceLinkTypes,
+ int transitivityDepth);
/**
* Given a trace model, this method returns a list of all trace links in the
- * model
+ * model.
*
* @param traceModel
- * @return A list of all connections in the trace model with the following
- * structure [Source, target(s) and the connecting trace link]
+ * @return a list of all connections in the trace model
*/
List<Connection> getAllTraceLinks(EObject traceModel);
/**
* Deletes specific trace links from a given trace model. This is useful for
* example when you want to delete links based on a quick fix from the
- * notification feature
+ * notification feature.
*
* @param toDelete a list of links to be deleted
* @param traceModel the trace model to delete the links from
@@ -153,51 +198,67 @@
void deleteTrace(List<Connection> toDelete, EObject traceModel);
/**
- * Determine a list of all objects internally connected to element (e.g. UML)
+ * Determine a list of all connections in which {@code element} is the origin,
+ * including connections that result from internal relationships in a DSL.
+ * Effectively, this method thus returns the same connections as
+ * {@link #getConnectedElements(EObject, EObject, List)} plus the connections
+ * resulting from internal relationships.
*
- * @param element The element used to determine the list of
- * connected objects. Note that this element
- * could be a trace in the trace model
- * @param traceModel Trace model to base calculation on
- * @param selectedRelationshipTypes List of selected relationship types from the
- * context menu of plantuml
- * @param traceLinksTransitive Used to determine if tracelink elements
- * should be received transitively
- * @param transitivityDepth Used to in case tracelinks are received
- * transivitely in order to set the depth
- * @return A Map with the following structure: [Trace object t -> {list of all
- * objects connected to element via t}]
+ * This method delegates the determination which internal relationships should
+ * be exposed to Eclipse Capra this way to the handler of the DSL. It is,
+ * however, possible to limit the relationship types by providing a non-null,
+ * non-empty list of relationship type names in {@code relationshipTypes}.
+ *
+ * @param element The element used to determine the list of connected
+ * objects. Note that this element could be a trace in the
+ * trace model.
+ * @param traceModel Trace model to base calculation on
+ * @param traceLinkTypes Relationship types to include. All relationship types
+ * are included if this list is {@code null} or empty.
+ * @return a list of {@link Connection}s that represent trace links as well as
+ * relationships within the model in the DSL in which {@code element} is
+ * formulated.
*/
- List<Connection> getInternalElements(EObject element, EObject traceModel, List<String> selectedRelationshipTypes,
- boolean traceLinksTransitive, int transitivityDepth, List<Connection> existingTraces);
+ List<Connection> getInternalElements(EObject element, EObject traceModel, List<String> traceLinkTypes);
/**
- * Determine a list of elements internally connected to the selected one
- * transitively
+ * Determine a list of all connections in which {@code element} is the origin,
+ * including connections that result from internal relationships in a DSL and
+ * transitive connections up to the specified depth. Effectively, this method
+ * thus returns the same connections as
+ * {@link #getTransitivelyConnectedElements(EObject, EObject, List, int)} plus
+ * the connections resulting from internal relationships.
+ *
+ * This method delegates the determination which internal relationships should
+ * be exposed to Eclipse Capra this way to the handler of the DSL. It is,
+ * however, possible to limit the relationship types by providing a non-null,
+ * non-empty list of relationship type names in {@code relationshipTypes}.
*
* @param element The element used to determine the list of connected
* objects. Note that this element could be a trace in
- * the trace model
+ * the trace model.
* @param traceModel Trace model to base calculation on
+ * @param traceLinkTypes Relationship types to include. All relationship
+ * types are included if this list is {@code null} or
+ * empty.
* @param transitivityDepth The maximum depth the user wants to go down
* transitively. 0 indicates no limit.
- * @return A Map with the following structure: [Trace object t -> {list of all
- * objects connected to element via t}]
+ * @return a list of {@link Connection}s that represent relationships within the
+ * model in the DSL in which {@code element} is formulated.
*/
- List<Connection> getInternalElementsTransitive(EObject element, EObject traceModel,
- List<String> selectedRelationshipTypes, int transitivityDepth, List<Connection> existingTraces);
+ List<Connection> getInternalElementsTransitive(EObject element, EObject traceModel, List<String> traceLinkTypes,
+ int transitivityDepth);
/**
- * Decide if two objects are connected internally by passing the selected
- * objects down to the artifact handlers and returns a String with the Type of
- * connection for the trace matrix (empty String if no connection exists) This
- * is implemented in the {@link AbstractMetaModelAdapter} and does not need to
- * be overwritten but can be used like it is.
+ * Decide if two objects are connected internally. This method is implemented by
+ * passing the selected objects down to the artifact handlers. It returns
+ * {@code true} if and only if the artifact handler determines that there is a
+ * relevant internal relationship between the two provided objects.
*
* @param first First object
* @param second Second object
- * @return <code>true</code> if object are connected, <code>false</code>
- * otherwise
+ * @return <code>true</code> if the objects are internally connected,
+ * <code>false</code> otherwise
*/
boolean isThereAnInternalTraceBetween(EObject first, EObject second);
}
diff --git a/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/TracePersistenceAdapter.java b/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/TracePersistenceAdapter.java
index b6a2f71..b4e0be2 100644
--- a/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/TracePersistenceAdapter.java
+++ b/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/adapters/TracePersistenceAdapter.java
@@ -28,56 +28,33 @@
/**
* Load and return the trace model in the given resource set
*
- * @param resourceSet
- * Resource set to load the trace model in
- * @return Root of loaded trace model, Optional can be empty to indicate
- * that loading failed or was not possible (there is no trace model
- * to load at the moment)
+ * @param resourceSet Resource set to load the trace model in
+ * @return Root of loaded trace model, Optional can be empty to indicate that
+ * loading failed or was not possible (there is no trace model to load
+ * at the moment)
*/
EObject getTraceModel(ResourceSet resourceSet);
/**
- * Return the trace model for the given object
+ * Load and return the container for all artifact wrappers in the given resource
+ * set
*
- * @param object
- * EObject to return the model for
- * @return Root of trace model, Optional can be empty to indicate that there
- * is no trace model for the object
- */
- EObject getTraceModel(EObject object);
-
- /**
- * Load and return the container for all artifact wrappers in the given
- * resource set
- *
- * @param resourceSet
- * Resource set to load the container for artifact wrappers in
+ * @param resourceSet Resource set to load the container for artifact wrappers
+ * in
* @return Container for all artifact wrappers, Optional can be empty to
- * indicate that loading failed or was not possible (no container
- * exists at the moment)
+ * indicate that loading failed or was not possible (no container exists
+ * at the moment)
*/
EObject getArtifactWrappers(ResourceSet resourceSet);
/**
- * Return the trace model for the given object
+ * Save the trace and artifact models. Implementations are expected to: (i) save
+ * the trace model, (ii) check selectionForTraceCreation for artifact wrappers
+ * that are not already contained in artifactWrappers, (iii) add these new
+ * artifact wrappers to artifactWrappers before saving it as well
*
- * @param object
- * EObject to return the model for
- * @return Root of trace model, Optional can be empty to indicate that there
- * is no trace model for the object
- */
- EObject getArtifactWrappers(EObject object);
-
- /**
- * Save the trace and artifact models. Implementations are expected to: (i)
- * save the trace model, (ii) check selectionForTraceCreation for artifact
- * wrappers that are not already contained in artifactWrappers, (iii) add
- * these new artifact wrappers to artifactWrappers before saving it as well
- *
- * @param traceModel
- * The updated trace model to be saved
- * @param artifactModel
- * The updated artifacts to be saved
+ * @param traceModel The updated trace model to be saved
+ * @param artifactModel The updated artifacts to be saved
*/
void saveTracesAndArtifacts(EObject traceModel, EObject artifactModel);
}
diff --git a/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/handlers/IArtifactHandler.java b/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/handlers/IArtifactHandler.java
index b76913c..815b37c 100644
--- a/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/handlers/IArtifactHandler.java
+++ b/bundles/org.eclipse.capra.core/src/org/eclipse/capra/core/handlers/IArtifactHandler.java
@@ -22,12 +22,11 @@
import org.eclipse.emf.ecore.EObject;
/**
- * This interface defines functionality required to map chosen Objects in the
+ * This interface defines functionality required to map selected objects in the
* Eclipse workspace to wrappers which can then be traced and persisted in EMF
* models.
*
- * @param <T>
- * The type of artifact that this object can handle. A handler with a
+ * @param <T> The type of artifact that this object can handle. A handler with a
* parameter T should return true when
* {@link IArtifactHandler#canHandleArtifact} is called with an
* object of that type.
@@ -37,8 +36,7 @@
/**
* Does the handler support this object?
*
- * @param artifact
- * The object to be wrapped
+ * @param artifact The object to be wrapped
* @return <code>true</code> if object can be handled, <code>false</code>
* otherwise.
*/
@@ -48,47 +46,41 @@
* If this handler can handle artifact, then call the functions with the
* argument and this handler as arguments.
* <p/>
- * This methods can be used to handle artifacts in a type safe manner when
- * the caller is sure that the artifact can be handled. Inside the handle
- * function it will be possible to use the handler with this specific
- * artifact only.
+ * This methods can be used to handle artifacts in a type safe manner when the
+ * caller is sure that the artifact can be handled. Inside the handle function
+ * it will be possible to use the handler with this specific artifact only.
*
- * @param artifact
- * The artifact to be handled
- * @param handleFunction
- * Must not return null.
- * @return An optional with the result returned from the handle function if
- * the artifact can be handled; otherwise an empty optional.
+ * @param artifact The artifact to be handled
+ * @param handleFunction Must not return null.
+ * @return An optional with the result returned from the handle function if the
+ * artifact can be handled; otherwise an empty optional.
*/
<R> Optional<R> withCastedHandler(Object artifact, BiFunction<IArtifactHandler<T>, T, R> handleFunction);
/**
- * Convenience method that calls {@link IArtifactHandler#withCastedHandler}
- * if caller knows that the artifact can be handled.
+ * Convenience method that calls {@link IArtifactHandler#withCastedHandler} if
+ * caller knows that the artifact can be handled.
*
- * @throws IllegalArgumentException
- * If this handler can not handle the artifact.
+ * @throws IllegalArgumentException If this handler can not handle the artifact.
*/
<R> R withCastedHandlerUnchecked(Object artifact, BiFunction<IArtifactHandler<T>, T, R> handleFunction);
/**
- * Create a wrapper for the object
+ * Create a wrapper for the provided artifact
*
- * @param artifact
- * The object to be wrapped
- * @param artifactModel
+ * @param artifact The artifact to be wrapped
+ * @param artifactModel The artifact model in which the wrapper should reside
* @return
*/
EObject createWrapper(T artifact, EObject artifactModel);
/**
- * Resolve the wrapper to the originally selected Object from the Eclipse
- * workspace. This is essentially the inverse of the createWrapper
+ * Resolve the wrapper to the original artifact from the Eclipse workspace. This
+ * is essentially the inverse of the {@link #createWrapper(Object, EObject)}
* operation.
*
- * @param wrapper
- * The wrapped object
- * @return originally selected object
+ * @param wrapper The wrapped object
+ * @return the original artifact
*/
T resolveWrapper(EObject wrapper);
@@ -102,58 +94,51 @@
/**
* Returns the type that is handled by this <code>IArtifactHandler</code>.
*
- * @return the type that
+ * @return the type
*/
Class<T> getHandledClass();
/**
- * When a change in the resource occurs, it generates the message that is to
- * be displayed by the Capra marker.
+ * Generates the message that is to be displayed by the Eclipse Capra marker
+ * when a change in the resource occurs, it
*
- * @param delta
- * represents changes in the state of a resource
- * @param wrapperUri
- * uri of the artifact that is associated with the change
- * @return the Capra marker message. Every marker must return a unique
- * message. If the message already exists it will be ignoored and a
- * marker will not be created.
+ * @param delta represents changes in the state of a resource
+ * @param wrapperUri uri of the artifact that is associated with the change
+ * @return the Capra marker message. Every marker must return a unique message.
+ * If the message already exists it will be ignored and a marker will
+ * not be created.
*/
String generateMarkerMessage(IResourceDelta delta, String wrapperUri);
/**
- * Adds internal links related to a given element.
+ * Retrieves internal links related to the given element.
* <p>
* This is helpful if Eclipse Capra should include links within a DSL, e.g.,
- * associations between classes, in its visualisations and analysis. A
+ * associations between classes in UML, in its visualisations and analysis. A
* handler that implements this method should return a list of
- * {@code Connection}. This list will be used in visualisations and
- * analysis, but not persisted in Capra's own trace model.
+ * {@code Connection}. This list will be used in visualisations and analysis,
+ * but not persisted in Capra's own trace model.
*
- * @param investigatedElement
- * element currently under investigation for links
- * @param selectedRelationshipTypes
- * relationship types selected by the user; this ensures that
- * Capra only includes specific link types in the visualisation
- * and analysis and implementation of the method should filter on
- * this list
+ * @param investigatedElement element currently under investigation for
+ * links
+ * @param selectedRelationshipTypes relationship types selected by the user;
+ * this ensures that Capra only includes
+ * specific link types in the visualisation and
+ * analysis and implementation of the method
+ * should filter on this list
*
- * @return a list of {@link Connection} between the
- * {@code investigatedElement} and other elements the handler takes
- * care of
+ * @return a list of {@link Connection} between the {@code investigatedElement}
+ * and other elements the handler takes care of
*/
- List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes);
+ List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes);
/**
* Decide if two objects have an internal link between them.
*
- * @param first
- * First object
- * @param second
- * Second object
- * @param traceModel
- * Trace model to base decision on
- * @return <code>true</code> if object are connected, <code>false</code>
- * otherwise
+ * @param first First object
+ * @param second Second object
+ * @return <code>true</code> if the given objects are internally connected,
+ * <code>false</code> otherwise
*/
boolean isThereAnInternalTraceBetween(EObject first, EObject second);
diff --git a/bundles/org.eclipse.capra.generic.persistence/src/org/eclipse/capra/generic/persistance/TracePersistenceAdapter.java b/bundles/org.eclipse.capra.generic.persistence/src/org/eclipse/capra/generic/persistance/TracePersistenceAdapter.java
index 0cf0072..4b65e73 100644
--- a/bundles/org.eclipse.capra.generic.persistence/src/org/eclipse/capra/generic/persistance/TracePersistenceAdapter.java
+++ b/bundles/org.eclipse.capra.generic.persistence/src/org/eclipse/capra/generic/persistance/TracePersistenceAdapter.java
@@ -155,17 +155,4 @@
ArtifactMetaModelAdapter adapter = ExtensionPointHelper.getArtifactWrapperMetaModelAdapter().orElseThrow();
return loadModel(resourceSet, DEFAULT_ARTIFACT_WRAPPER_MODEL_NAME).orElse(adapter.createModel());
}
-
- @Override
- public EObject getTraceModel(EObject object) {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public EObject getArtifactWrappers(EObject object) {
- // TODO Auto-generated method stub
- return null;
- }
-
}
diff --git a/bundles/org.eclipse.capra.generic.tracemodel/src/org/eclipse/capra/generic/tracemodel/GenericMetaModelAdapter.java b/bundles/org.eclipse.capra.generic.tracemodel/src/org/eclipse/capra/generic/tracemodel/GenericMetaModelAdapter.java
index 88a7102..b028525 100644
--- a/bundles/org.eclipse.capra.generic.tracemodel/src/org/eclipse/capra/generic/tracemodel/GenericMetaModelAdapter.java
+++ b/bundles/org.eclipse.capra.generic.tracemodel/src/org/eclipse/capra/generic/tracemodel/GenericMetaModelAdapter.java
@@ -36,7 +36,10 @@
import org.eclipse.emf.transaction.TransactionalEditingDomain;
/**
- * Provides generic functionality to deal with traceability meta models.
+ * Provides functionality to access the generic trace meta-model. This trace
+ * meta-model only contains one link type {@code RelatedTo} that can be used to
+ * relate any artifacts to each other. It is directed and has a single origin
+ * artifacts and one or more target artifacts.
*/
public class GenericMetaModelAdapter extends AbstractMetaModelAdapter implements TraceMetaModelAdapter {
@@ -235,15 +238,15 @@
@Override
public List<Connection> getTransitivelyConnectedElements(EObject element, EObject traceModel,
- List<String> selectedRelationshipTypes, int maximumDepth) {
+ List<String> traceLinkTypes, int maximumDepth) {
List<Object> accumulator = new ArrayList<>();
- return getTransitivelyConnectedElements(element, traceModel, accumulator, selectedRelationshipTypes,
+ return getTransitivelyConnectedElements(element, traceModel, accumulator, traceLinkTypes,
DEFAULT_INITIAL_TRANSITIVITY_DEPTH, maximumDepth);
}
private List<Connection> getTransitivelyConnectedElements(EObject element, EObject traceModel,
- List<Object> accumulator, List<String> selectedRelationshipTypes, int currentDepth, int maximumDepth) {
- List<Connection> directElements = getConnectedElements(element, traceModel, selectedRelationshipTypes);
+ List<Object> accumulator, List<String> traceLinkTypes, int currentDepth, int maximumDepth) {
+ List<Connection> directElements = getConnectedElements(element, traceModel, traceLinkTypes);
List<Connection> allElements = new ArrayList<>();
int currDepth = currentDepth + 1;
for (Connection connection : directElements) {
@@ -252,8 +255,8 @@
accumulator.add(connection.getTlink());
for (EObject e : connection.getTargets()) {
if (maximumDepth == 0 || currDepth <= maximumDepth) {
- allElements.addAll(getTransitivelyConnectedElements(e, traceModel, accumulator,
- selectedRelationshipTypes, currDepth, maximumDepth));
+ allElements.addAll(getTransitivelyConnectedElements(e, traceModel, accumulator, traceLinkTypes,
+ currDepth, maximumDepth));
}
}
}
diff --git a/bundles/org.eclipse.capra.handler.app4mc/src/org/eclipse/capra/handler/app4mc/APP4MCHandler.java b/bundles/org.eclipse.capra.handler.app4mc/src/org/eclipse/capra/handler/app4mc/APP4MCHandler.java
index 1c9d103..0ba4c7a 100644
--- a/bundles/org.eclipse.capra.handler.app4mc/src/org/eclipse/capra/handler/app4mc/APP4MCHandler.java
+++ b/bundles/org.eclipse.capra.handler.app4mc/src/org/eclipse/capra/handler/app4mc/APP4MCHandler.java
@@ -67,7 +67,7 @@
}
@Override
- public List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
+ public List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
List<Connection> connections = new ArrayList<>();
if (investigatedElement instanceof INamed) {
INamed named = (INamed) investigatedElement;
diff --git a/bundles/org.eclipse.capra.handler.cdt/src/org/eclipse/capra/handler/cdt/CDTHandler.java b/bundles/org.eclipse.capra.handler.cdt/src/org/eclipse/capra/handler/cdt/CDTHandler.java
index de712ca..9a6f048 100644
--- a/bundles/org.eclipse.capra.handler.cdt/src/org/eclipse/capra/handler/cdt/CDTHandler.java
+++ b/bundles/org.eclipse.capra.handler.cdt/src/org/eclipse/capra/handler/cdt/CDTHandler.java
@@ -99,7 +99,7 @@
}
@Override
- public List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
+ public List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
// Method currently left empty to wait for user requirements of relevant
// internal links for C code
return Collections.emptyList();
diff --git a/bundles/org.eclipse.capra.handler.emf/src/org/eclipse/capra/handler/emf/EMFHandler.java b/bundles/org.eclipse.capra.handler.emf/src/org/eclipse/capra/handler/emf/EMFHandler.java
index 0d81f26..2e65713 100644
--- a/bundles/org.eclipse.capra.handler.emf/src/org/eclipse/capra/handler/emf/EMFHandler.java
+++ b/bundles/org.eclipse.capra.handler.emf/src/org/eclipse/capra/handler/emf/EMFHandler.java
@@ -48,7 +48,7 @@
}
@Override
- public List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
+ public List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
// Method currently left empty to wait for user requirements of relevant
// internal links for EMF models
return Collections.emptyList();
diff --git a/bundles/org.eclipse.capra.handler.featureide/src/org/eclipse/capra/handler/featureide/FeatureIdeHandler.java b/bundles/org.eclipse.capra.handler.featureide/src/org/eclipse/capra/handler/featureide/FeatureIdeHandler.java
index 9f11d3a..8e7ccb4 100644
--- a/bundles/org.eclipse.capra.handler.featureide/src/org/eclipse/capra/handler/featureide/FeatureIdeHandler.java
+++ b/bundles/org.eclipse.capra.handler.featureide/src/org/eclipse/capra/handler/featureide/FeatureIdeHandler.java
@@ -76,7 +76,7 @@
}
@Override
- public List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
+ public List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
// Method currently left empty to wait for user requirements of relevant
// internal links for FeatureIDE models
return Collections.emptyList();
diff --git a/bundles/org.eclipse.capra.handler.file/src/org/eclipse/capra/handler/file/FileHandler.java b/bundles/org.eclipse.capra.handler.file/src/org/eclipse/capra/handler/file/FileHandler.java
index 91fbaf4..6022f34 100644
--- a/bundles/org.eclipse.capra.handler.file/src/org/eclipse/capra/handler/file/FileHandler.java
+++ b/bundles/org.eclipse.capra.handler.file/src/org/eclipse/capra/handler/file/FileHandler.java
@@ -60,7 +60,7 @@
}
@Override
- public List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
+ public List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
// Method currently left empty to wait for user requirements of relevant
// internal links for Files
return Collections.emptyList();
diff --git a/bundles/org.eclipse.capra.handler.gef/src/org/eclipse/capra/handler/gef/GEFHandler.java b/bundles/org.eclipse.capra.handler.gef/src/org/eclipse/capra/handler/gef/GEFHandler.java
index f10ac11..7245923 100644
--- a/bundles/org.eclipse.capra.handler.gef/src/org/eclipse/capra/handler/gef/GEFHandler.java
+++ b/bundles/org.eclipse.capra.handler.gef/src/org/eclipse/capra/handler/gef/GEFHandler.java
@@ -51,7 +51,7 @@
}
@Override
- public List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
+ public List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
// Method currently left empty to wait for user requirements of relevant
// internal links for GEF models
return Collections.emptyList();
diff --git a/bundles/org.eclipse.capra.handler.hudson/src/org/eclipse/capra/handler/hudson/BuildElementHandler.java b/bundles/org.eclipse.capra.handler.hudson/src/org/eclipse/capra/handler/hudson/BuildElementHandler.java
index 9bd5231..741d948 100644
--- a/bundles/org.eclipse.capra.handler.hudson/src/org/eclipse/capra/handler/hudson/BuildElementHandler.java
+++ b/bundles/org.eclipse.capra.handler.hudson/src/org/eclipse/capra/handler/hudson/BuildElementHandler.java
@@ -55,7 +55,7 @@
}
@Override
- public List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
+ public List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
// Method currently left empty to wait for user requirements of relevant
// internal links for Build elements
return Collections.emptyList();
diff --git a/bundles/org.eclipse.capra.handler.hudson/src/org/eclipse/capra/handler/hudson/TestElementHandler.java b/bundles/org.eclipse.capra.handler.hudson/src/org/eclipse/capra/handler/hudson/TestElementHandler.java
index 09bba02..c0a09dd 100644
--- a/bundles/org.eclipse.capra.handler.hudson/src/org/eclipse/capra/handler/hudson/TestElementHandler.java
+++ b/bundles/org.eclipse.capra.handler.hudson/src/org/eclipse/capra/handler/hudson/TestElementHandler.java
@@ -56,7 +56,7 @@
}
@Override
- public List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
+ public List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
// Method currently left empty to wait for user requirements of relevant
// internal links for Test elements
return Collections.emptyList();
diff --git a/bundles/org.eclipse.capra.handler.jdt/src/org/eclipse/capra/handler/jdt/JavaElementHandler.java b/bundles/org.eclipse.capra.handler.jdt/src/org/eclipse/capra/handler/jdt/JavaElementHandler.java
index bbf159f..23a92e7 100644
--- a/bundles/org.eclipse.capra.handler.jdt/src/org/eclipse/capra/handler/jdt/JavaElementHandler.java
+++ b/bundles/org.eclipse.capra.handler.jdt/src/org/eclipse/capra/handler/jdt/JavaElementHandler.java
@@ -160,7 +160,7 @@
}
@Override
- public List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
+ public List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
// Method currently left empty to wait for user requirements of relevant
// internal links for Java code
return Collections.emptyList();
diff --git a/bundles/org.eclipse.capra.handler.marker/src/org/eclipse/capra/handler/marker/MarkerHandler.java b/bundles/org.eclipse.capra.handler.marker/src/org/eclipse/capra/handler/marker/MarkerHandler.java
index 82ba25c..0b1d5c1 100644
--- a/bundles/org.eclipse.capra.handler.marker/src/org/eclipse/capra/handler/marker/MarkerHandler.java
+++ b/bundles/org.eclipse.capra.handler.marker/src/org/eclipse/capra/handler/marker/MarkerHandler.java
@@ -69,7 +69,7 @@
}
@Override
- public List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
+ public List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
// Method currently left empty to wait for user requirements of relevant
// internal links for Markers
return Collections.emptyList();
diff --git a/bundles/org.eclipse.capra.handler.mylyn/src/org/eclipse/capra/handler/mylyn/MylynHandler.java b/bundles/org.eclipse.capra.handler.mylyn/src/org/eclipse/capra/handler/mylyn/MylynHandler.java
index c5f7eca..45e7324 100644
--- a/bundles/org.eclipse.capra.handler.mylyn/src/org/eclipse/capra/handler/mylyn/MylynHandler.java
+++ b/bundles/org.eclipse.capra.handler.mylyn/src/org/eclipse/capra/handler/mylyn/MylynHandler.java
@@ -68,7 +68,7 @@
}
@Override
- public List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
+ public List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
// Method currently left empty to wait for user requirements of relevant
// internal links for Mylyn Tasks
return Collections.emptyList();
diff --git a/bundles/org.eclipse.capra.handler.office/src/org/eclipse/capra/handler/office/OfficeHandler.java b/bundles/org.eclipse.capra.handler.office/src/org/eclipse/capra/handler/office/OfficeHandler.java
index 9a8e303..3f59860 100644
--- a/bundles/org.eclipse.capra.handler.office/src/org/eclipse/capra/handler/office/OfficeHandler.java
+++ b/bundles/org.eclipse.capra.handler.office/src/org/eclipse/capra/handler/office/OfficeHandler.java
@@ -73,7 +73,7 @@
}
@Override
- public List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
+ public List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
// Method currently left empty to wait for user requirements of relevant
// internal links for Office documents.
return Collections.emptyList();
diff --git a/bundles/org.eclipse.capra.handler.papyrus/src/org/eclipse/capra/handler/papyrus/PapyrusHandler.java b/bundles/org.eclipse.capra.handler.papyrus/src/org/eclipse/capra/handler/papyrus/PapyrusHandler.java
index 17d9c66..d072145 100644
--- a/bundles/org.eclipse.capra.handler.papyrus/src/org/eclipse/capra/handler/papyrus/PapyrusHandler.java
+++ b/bundles/org.eclipse.capra.handler.papyrus/src/org/eclipse/capra/handler/papyrus/PapyrusHandler.java
@@ -53,7 +53,7 @@
}
@Override
- public List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
+ public List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
// Method currently left empty to wait for user requirements of relevant
// internal links specific for Papyrus models.
// Currently, UML links such as association and those from the SYSML
diff --git a/bundles/org.eclipse.capra.handler.php/src/org/eclipse/capra/handler/php/PhpHandler.java b/bundles/org.eclipse.capra.handler.php/src/org/eclipse/capra/handler/php/PhpHandler.java
index c986e5b..3d459c0 100644
--- a/bundles/org.eclipse.capra.handler.php/src/org/eclipse/capra/handler/php/PhpHandler.java
+++ b/bundles/org.eclipse.capra.handler.php/src/org/eclipse/capra/handler/php/PhpHandler.java
@@ -53,7 +53,7 @@
}
@Override
- public List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
+ public List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
// Method currently left empty to wait for user requirements of relevant
// internal links for PHP code.
return Collections.emptyList();
diff --git a/bundles/org.eclipse.capra.handler.reqIf/src/org/eclipse/capra/handler/reqif/ReqIfHandler.java b/bundles/org.eclipse.capra.handler.reqIf/src/org/eclipse/capra/handler/reqif/ReqIfHandler.java
index 93488d9..0c648e4 100644
--- a/bundles/org.eclipse.capra.handler.reqIf/src/org/eclipse/capra/handler/reqif/ReqIfHandler.java
+++ b/bundles/org.eclipse.capra.handler.reqIf/src/org/eclipse/capra/handler/reqif/ReqIfHandler.java
@@ -74,7 +74,7 @@
}
@Override
- public List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
+ public List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
if (investigatedElement instanceof SpecHierarchy) {
SpecHierarchy spec = (SpecHierarchy) investigatedElement;
diff --git a/bundles/org.eclipse.capra.handler.uml/src/org/eclipse/capra/handler/uml/UMLHandler.java b/bundles/org.eclipse.capra.handler.uml/src/org/eclipse/capra/handler/uml/UMLHandler.java
index fabe323..5493897 100644
--- a/bundles/org.eclipse.capra.handler.uml/src/org/eclipse/capra/handler/uml/UMLHandler.java
+++ b/bundles/org.eclipse.capra.handler.uml/src/org/eclipse/capra/handler/uml/UMLHandler.java
@@ -60,7 +60,7 @@
}
@Override
- public List<Connection> addInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
+ public List<Connection> getInternalLinks(EObject investigatedElement, List<String> selectedRelationshipTypes) {
List<Integer> duplicationCheck = new ArrayList<>();
List<Connection> allElements = new ArrayList<>();
if (Relationship.class.isAssignableFrom(investigatedElement.getClass())) {
diff --git a/bundles/org.eclipse.capra.ui.plantuml/src/org/eclipse/capra/ui/plantuml/DiagramTextProviderHandler.java b/bundles/org.eclipse.capra.ui.plantuml/src/org/eclipse/capra/ui/plantuml/DiagramTextProviderHandler.java
index f413d82..51fab3f 100644
--- a/bundles/org.eclipse.capra.ui.plantuml/src/org/eclipse/capra/ui/plantuml/DiagramTextProviderHandler.java
+++ b/bundles/org.eclipse.capra.ui.plantuml/src/org/eclipse/capra/ui/plantuml/DiagramTextProviderHandler.java
@@ -213,7 +213,7 @@
SelectRelationshipsHandler.setPreviousElement(selectedObject);
}
traces.addAll(metamodelAdapter.getInternalElementsTransitive(selectedObject, traceModel,
- selectedRelationshipTypes, transitivityDepth, traces));
+ selectedRelationshipTypes, transitivityDepth));
} else if (DisplayInternalLinksHandler.areInternalLinksShown()) {
EObject previousElement = SelectRelationshipsHandler.getPreviousElement();
if (previousElement != null) {
@@ -227,8 +227,7 @@
} else {
SelectRelationshipsHandler.setPreviousElement(selectedObject);
}
- traces.addAll(metamodelAdapter.getInternalElements(selectedObject, traceModel, selectedRelationshipTypes,
- false, 0, traces));
+ traces.addAll(metamodelAdapter.getInternalElements(selectedObject, traceModel, selectedRelationshipTypes));
}
List<EObject> links = extractLinksFromTraces(traces);
SelectRelationshipsHandler.addToPossibleRelationsForSelection(links);
diff --git a/bundles/org.eclipse.capra.ui.plantuml/xtend-gen/org/eclipse/capra/ui/plantuml/.VisualizationHelper.xtendbin b/bundles/org.eclipse.capra.ui.plantuml/xtend-gen/org/eclipse/capra/ui/plantuml/.VisualizationHelper.xtendbin
index 59c2741..28d8e8d 100644
--- a/bundles/org.eclipse.capra.ui.plantuml/xtend-gen/org/eclipse/capra/ui/plantuml/.VisualizationHelper.xtendbin
+++ b/bundles/org.eclipse.capra.ui.plantuml/xtend-gen/org/eclipse/capra/ui/plantuml/.VisualizationHelper.xtendbin
Binary files differ
