worked on xml-serialization for pnml split

src/main/jastadd/io/IoPN.jadd

@@ -12,13 +12,16 @@ aspect IoPnExtension{
 
         eq Page.getObject().containingPlace() = null;
 
-        syn lazy JastAddList<InputSignalBinding> InputSignalTransition.getInputSignalBindingList() {
+        syn lazy JastAddList<InputSignalBinding> InputSignalTransition.getStaticInputSignalBindingList() {
 
+            if(this.getMutualInputSignalBindingList() == null || this.getMutualInputSignalBindingList().getNumChild() == 0){
                 JastAddList<InputSignalBinding> isBindings = de.tudresden.inf.st.postprocessing.IoPetriNetPostProcessor.parseInputSignalBindingDefinitions(this.getToolspecificList());
-
                 return isBindings;
             }
 
+            return this.getMutualInputSignalBindingList();
+        }
+
         syn lazy JastAddList<OutputSignalBinding> OutputSignalPlace.getOutputSignalBindingList() {
 
             JastAddList<OutputSignalBinding> osBindings = de.tudresden.inf.st.postprocessing.IoPetriNetPostProcessor.parseOutputSignalBindingDefinitions(this.getToolspecificList());

src/main/jastadd/io/IoPN.relast

@@ -3,7 +3,7 @@ OutputSignalBinding : PnObject ::= <PlaceID:String> <OutputSignalID:String> /<Ou
 TransitionInformation ::= <Location:String> <Type:String> <InputLimit:java.lang.Integer> <OutputLimit:java.lang.Integer> <Topic:String> <SubNet:String>;
 PlaceInformation ::= <Location:String> <Type:String> <SubNet:String>;
 
-InputSignalTransition : Transition ::= /InputSignalBinding*/ /TransitionInformation/;
+InputSignalTransition : Transition ::= /StaticInputSignalBinding:InputSignalBinding*/  MutualInputSignalBinding:InputSignalBinding* /TransitionInformation/;
 OutputSignalPlace : Place ::= /OutputSignalBinding*/;
 
 OutputMapping;

src/main/java/de/tudresden/inf/st/postprocessing/GlobalToLocalNetsPostProcessor.java

@@ -4,7 +4,19 @@ import de.tudresden.inf.st.pnml.PnmlConstants;
 import de.tudresden.inf.st.pnml.jastadd.model.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import java.io.StringWriter;
 import java.util.HashSet;
 import java.util.Set;
 
@@ -58,35 +70,54 @@ public class GlobalToLocalNetsPostProcessor implements PostProcessor<PetriNet> {
                 sourceIst.getTransitionInformation().setSubNet(inSubNet);
                 sourceIst.getTransitionInformation().setLocation(inLocation);
 
-                // TODO: the attributized infos need to be written back to XML
-                sourceIst.setToolspecificList(new JastAddList<>());
+                // attributized infos need to be written back to XML
+                JastAddList<ToolInfo> inputToolInfoJastAddList = new JastAddList<>();
 
                 if (channelIst.getTransitionInformation().getInputLimit() >= 0) {
                     sourceIst.getTransitionInformation().setType(PnmlConstants.TRANSITION_TOPIC_TYPE_LIMITED_OUT);
+                    inputToolInfoJastAddList.add(buildToolSpecifics(PnmlConstants.TRANSITION_TOPIC_TYPE_LIMITED_OUT, inLocation, inSubNet,
+                            channelIst.getTransitionInformation().getInputLimit(), channelIst.getTransitionInformation().getOutputLimit(), channelIst.getStaticInputSignalBindingList()));
                 } else {
                     sourceIst.getTransitionInformation().setType(PnmlConstants.TRANSITION_TOPIC_TYPE_UNLIMITED_OUT);
+                    inputToolInfoJastAddList.add(buildToolSpecifics(PnmlConstants.TRANSITION_TOPIC_TYPE_UNLIMITED_OUT, inLocation, inSubNet,
+                            channelIst.getTransitionInformation().getInputLimit(), channelIst.getTransitionInformation().getOutputLimit(), channelIst.getStaticInputSignalBindingList()));
                 }
 
+                sourceIst.setToolspecificList(inputToolInfoJastAddList);
+
                 InputSignalTransition targetIst = new InputSignalTransition();
                 targetIst.setName(new Name().setText(channelIst.getName().getText() + "-target"));
                 targetIst.setId(channelIst.getId() + "-target");
                 targetIst.getTransitionInformation().setSubNet(outSubNet);
                 targetIst.getTransitionInformation().setLocation(outLocation);
 
-                // TODO: the attributized infos need to be written back to XML
-                targetIst.setToolspecificList(new JastAddList<>());
+                // attributized infos need to be written back to XML
+                JastAddList<ToolInfo> outputToolInfoJastAddList = new JastAddList<>();
+
+                targetIst.setToolspecificList(outputToolInfoJastAddList);
 
                 if (channelIst.getTransitionInformation().getOutputLimit() >= 0) {
                     targetIst.getTransitionInformation().setType(PnmlConstants.TRANSITION_TOPIC_TYPE_LIMITED_IN);
+                    outputToolInfoJastAddList.add(buildToolSpecifics(PnmlConstants.TRANSITION_TOPIC_TYPE_LIMITED_IN, outLocation, outSubNet,
+                            channelIst.getTransitionInformation().getInputLimit(), channelIst.getTransitionInformation().getOutputLimit(), null));
                 } else {
                     targetIst.getTransitionInformation().setType(PnmlConstants.TRANSITION_TOPIC_TYPE_UNLIMITED_IN);
+                    outputToolInfoJastAddList.add(buildToolSpecifics(PnmlConstants.TRANSITION_TOPIC_TYPE_UNLIMITED_IN, outLocation, outSubNet,
+                            channelIst.getTransitionInformation().getInputLimit(), channelIst.getTransitionInformation().getOutputLimit(), null));
                 }
 
 
                 // STEP 2: Reconnect Input Signals
-                //for(InputSignalBinding isb : channelIst.getInputSignalBindingList()){
-                //    inputIst.addInputSignalBinding(isb);
-                //}
+                for(InputSignalBinding isb : channelIst.getMutualInputSignalBindingList()){
+
+                    InputSignalBinding newIsb = new InputSignalBinding();
+                    newIsb.setInputSignalValue(isb.getInputSignalValue());
+                    newIsb.setTransitionID(isb.getTransitionID());
+                    newIsb.setId(isb.getId());
+                    newIsb.setInputSignalID(isb.getInputSignalID());
+
+                    sourceIst.addMutualInputSignalBinding(newIsb);
+                }
 
                 // STEP 3: Get all incoming arcs and connect them to new output transition
                 for (Arc arc : channelIst.getInArcList().toArray(new Arc[0])) {
@@ -126,14 +157,85 @@ public class GlobalToLocalNetsPostProcessor implements PostProcessor<PetriNet> {
         return petriNet;
     }
 
-    private static StringBuffer buildToolSpecifics(String type, String location, String subnet, String inputLimit, String outputLimit){
+    private static ToolInfo buildToolSpecifics(String type, String location, String subnet, int inputLimit, int outputLimit, JastAddList<InputSignalBinding> inputSignalBindings) {
+
+        try {
+            DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
+            DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
+
+            Document doc = docBuilder.newDocument();
+            Element rootElement = doc.createElement("toolspecific");
+            rootElement.setAttribute("tool", "de.tudresden.inf.st.pnml.distributedPN");
+            rootElement.setAttribute("version", "0.0.1");
+            doc.appendChild(rootElement);
+
+            Element loc = doc.createElement("location");
+            loc.appendChild(doc.createTextNode(location));
+            rootElement.appendChild(loc);
+
+            Element ctype = doc.createElement("type");
+            ctype.appendChild(doc.createTextNode(type));
+            rootElement.appendChild(ctype);
+
+            Element net = doc.createElement("subnet");
+            net.appendChild(doc.createTextNode(subnet));
+            rootElement.appendChild(net);
+
+            Element inLimit = doc.createElement("inputlimit");
+            inLimit.appendChild(doc.createTextNode(String.valueOf(inputLimit)));
+            rootElement.appendChild(inLimit);
+
+            Element outLimit = doc.createElement("outputlimit");
+            outLimit.appendChild(doc.createTextNode(String.valueOf(outputLimit)));
+            rootElement.appendChild(outLimit);
+
+            Element bindings = doc.createElement("inputsignalbindings");
+
+            for(InputSignalBinding isb : inputSignalBindings){
+
+                Element binding = doc.createElement("inputsignalbinding");
+
+                Element transitionID = doc.createElement("transitionID");
+                transitionID.appendChild(doc.createTextNode(isb.getTransitionID()));
+                binding.appendChild(transitionID);
+
+                Element inputsignalID = doc.createElement("inputsignalID");
+                inputsignalID.appendChild(doc.createTextNode(isb.getInputSignalID()));
+                binding.appendChild(inputsignalID);
+
+                Element initialvalue = doc.createElement("initialvalue");
+                initialvalue.appendChild(doc.createTextNode(String.valueOf(isb.getInputSignalValue())));
+                binding.appendChild(initialvalue);
+
+                bindings.appendChild(binding);
+            }
+
+            rootElement.appendChild(bindings);
+
+            TransformerFactory tf = TransformerFactory.newInstance();
+            Transformer trans = tf.newTransformer();
+            StringWriter sw = new StringWriter();
+            trans.transform(new DOMSource(doc), new StreamResult(sw));
+
+            ToolInfo toolInfo = new ToolInfo();
+            toolInfo.setFormattedXMLBuffer(sw.getBuffer());
+            toolInfo.setVersion("0.0.1");
+            toolInfo.setTool("de.tudresden.inf.st.pnml.distributedPN");
+
+            return toolInfo;
+        } catch (ParserConfigurationException | TransformerConfigurationException pce) {
+            pce.printStackTrace();
+        } catch (TransformerException e) {
+            e.printStackTrace();
+        }
 
-        // TODO TBD
         return null;
     }
 
     private static void printNet(PetriNet petriNet) {
 
+        logger.info("--------------- STRUCTURE ---------------");
+
         for (Transition t : petriNet.allTransitions()) {
 
             logger.info("--- Transiton: " + t.getName().getText() + " ---------");
@@ -153,5 +255,15 @@ public class GlobalToLocalNetsPostProcessor implements PostProcessor<PetriNet> {
 
             logger.info("Arc: " + a.getId() + " -- source: " + a.getSource().getName().getText() + " -- target: " + a.getTarget().getName().getText());
         }
+
+        logger.info("--------------- SIGNALS ---------------");
+
+        for (Transition t : petriNet.allTransitions()) {
+            InputSignalTransition ist = t.asInputSignalTransition();
+
+            if (ist != null && ist.getStaticInputSignalBindingList() != null) {
+                ist.getStaticInputSignalBindingList().forEach(inputSignalBinding -> logger.info(" (" + t.getName().getText() + ") Signal: " + inputSignalBinding.getInputSignalID()));
+            }
+        }
     }
 }

src/main/java/de/tudresden/inf/st/postprocessing/IoPetriNetPostProcessor.java

@@ -36,6 +36,8 @@ public class IoPetriNetPostProcessor implements PostProcessor<PetriNet> {
 
     private static JastAddList<InputSignalBinding> parseInputSignalBindingDefinitionsInternal(Document doc) {
 
+        logger.error("!!!");
+
         NodeList isBindingDefList = doc.getElementsByTagName(PnmlConstants.INPUT_SIGNAL_BINDINGS_KEY);
         JastAddList<InputSignalBinding> jastAddBindingList = new JastAddList<>();
 
@@ -167,8 +169,6 @@ public class IoPetriNetPostProcessor implements PostProcessor<PetriNet> {
 
         Document doc = dBuilder.parse(fromStringBuffer(toolInfoStringBuffer));
         doc.getDocumentElement().normalize();
-
-        logger.error("############################# tttttttttttttttttttttttt");
         return doc;
     }