Hello,

in order to formulate my question I first would like to show how we plan to work (and why) to illustrate the intention behind this.

In our development we use a model based development tool which stores its data partly in simple xml files, partly in complex xml files and proprietary files. All those information form the whole project setting and can have strong relationships.

Now we consider the following setting:

• Our project consists of the components A and B. This e.g. generates two simple xml A.xml and B.xml. In addition we have a connection between those stored in the complex connection.xml and a project_setting.something which is used to load the whole project into the tool.
• Bob decides that component B needs some data from A and creates a incoming interface getValue for B which is matching to an already existing outgoing interface from A and connects both. This will generate changes in B.xml (new incoming interface), connection.xml and project_setting.something.
• Bob delivers the updates on the stream.
• Alice meanwhile notices that there is an change needed in the  configuration of setValue from component A. She fixes this interfaces in component A which will generate a new A.xml and can update project_setting.something. Since this interface so far was not connected it won't change connection.xml
• Alice recognizes that Bob delivered changes on the stream and accepts those. Following will happen now in Eclipse:
• A.xml was only updated locally, nothing will happen to it.
• project_setting.something might sees a merge conflict and in that case won't be updated.
• B.xml and connection.xml were only updated on the stream and will directly be updated to the local workspace when accepting the incoming.
• Now exactly this generates our problems. Considering only each file and it's changes by itself everything is fine. But if we look at the whole situation we have configured now a connection from A to B with a not matching interface. This will throw errors upon loading the project now into the tool and can corrupt the whole project setting.

To overcome this the supplier of the tool has build in a feature to correctly merge those updates. But currently we cannot imaging how we can in-cooperate this into RTC.
Basically as far as I see (and what the suppliers of the tool suggests) we would need to "virtually" accept those changes without updating the files in the local workspace immediately. Instead we would have a separate workspace which is in synch with the stream and used as source for merging the updates by the use of the dedicated tool.

In SVN we would do a merge to head revision with the "record-only" option, but I could not find a comparable way in RTC.

Are there any suggestions how to overcome this without changing a part of our toolchain?

Best Regards,
Sven