working on service split

src/main/jastadd/distribution/DistributedPN.jadd

@@ -10,10 +10,20 @@ aspect PnDistribution {
         return this.getMutualTransitionInformation();
     }
 
-    syn lazy PlaceInformation OutputSignalPlace.getPlaceInformation() {
+   /*  syn lazy PlaceInformation OutputSignalPlace.getPlaceInformation() {
 
         PlaceInformation pInfo = de.tudresden.inf.st.pnml.ToolSpecificsParser.getPlaceInformation(this.getToolspecificList());
 
         return pInfo;
+    }*/
+
+    syn lazy PlaceInformation OutputSignalPlace.getStaticTransitionInformation() {
+
+        if(this.getMutualPlaceInformation() == null){
+            PlaceInformation tInfo = de.tudresden.inf.st.pnml.ToolSpecificsParser.getPlaceInformationInformation(this.getToolspecificList());
+            return tInfo;
+        }
+
+        return this.getMutualPlaceInformation();
     }
 }
\ No newline at end of file

src/main/jastadd/io/IoPN.relast

 InputSignalBinding : PnObject ::= <TransitionID:String> <InputSignalID:String> <InputSignalValue:int>;
 OutputSignalBinding : PnObject ::= <PlaceID:String> <OutputSignalID:String> /<OutputSignalValue:String>/ EqualityOM:EqualityOutputMapping* ThresholdOM:ThresholdOutputMapping* RangeOM:RangeOutputMapping*;
 
-TransitionInformation ::= <Location:String> <Type:String> <InputLimit:java.lang.Integer> <OutputLimit:java.lang.Integer> <SubNet:String>;
+TransitionInformation ::= <Location:String> <Type:String> <InputLimit:java.lang.Integer> <OutputLimit:java.lang.Integer> <SubNet:String> <Instance:String>;
 TopicTransitionInformation : TransitionInformation ::= <Topic:String>;
 ServiceTransitionInformation : TransitionInformation ::= <ServiceName:String>;
-PlaceInformation ::= <Location:String> <Type:String> <SubNet:String>;
+PlaceInformation ::= <Location:String> <Type:String> <SubNet:String> <Instance:String>;
 
 InputSignalTransition : Transition ::= /StaticInputSignalBinding:InputSignalBinding*/ MutualInputSignalBinding:InputSignalBinding* /StaticTransitionInformation:TransitionInformation/ [MutualTransitionInformation:TransitionInformation];
-OutputSignalPlace : Place ::= /OutputSignalBinding*/;
+OutputSignalPlace : Place ::= /OutputSignalBinding*/ /StaticPlaceInformation:PlaceInformation/ [MutualPlaceInformation:PlaceInformation];
 
 OutputMapping;
 

src/main/java/de/tudresden/inf/st/pnml/Main.java

@@ -3,6 +3,7 @@ package de.tudresden.inf.st.pnml;
 import de.tudresden.inf.st.export.PnmlExporter;
 import de.tudresden.inf.st.pnml.jastadd.model.PetriNet;
 import de.tudresden.inf.st.postprocessing.GlobalToLocalNetsPostProcessor;
+import de.tudresden.inf.st.postprocessing.PostProcessingUtils;
 import fr.lip6.move.pnml.framework.utils.exception.InvalidIDException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -35,7 +36,7 @@ public class Main {
         for(int i = 0; i < disconnectedPetriNets.size(); i++){
             for(int j = 0; j < disconnectedPetriNets.get(i).size(); j++){
                 logger.info("Exporting splitted Petri net containing: ");
-                GlobalToLocalNetsPostProcessor.printNet(disconnectedPetriNets.get(i).get(j));
+                PostProcessingUtils.printNet(disconnectedPetriNets.get(i).get(j));
 
                 try {
                     PnmlExporter.serializeToPnmlFile(disconnectedPetriNets.get(i).get(j), "-pnml-net-" + i + "-" + j);

src/main/java/de/tudresden/inf/st/pnml/ToolSpecificsParser.java

@@ -222,6 +222,17 @@ public class ToolSpecificsParser {
         }
     }
 
+    public static PlaceInformation getPlaceInformationInformation(JastAddList<ToolInfo> toolInfos){
+
+        PlaceInformation placeInformation = new PlaceInformation();
+
+        placeInformation.setLocation(getLocationFromToolSpecifics(toolInfos));
+        placeInformation.setType(getTransitionTypeFromToolSpecifics(toolInfos));
+        placeInformation.setSubNet(getTransitionSubnetInfo(toolInfos));
+
+        return placeInformation;
+    }
+
     public static PlaceInformation getPlaceInformation(JastAddList<ToolInfo> toolInfos) {
 
         PlaceInformation pi = new PlaceInformation();

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

@@ -36,8 +36,11 @@ public class GlobalToLocalNetsPostProcessor implements PostProcessor<PetriNet> {
             // init list of distributed nets
             List<PetriNet> pns = new ArrayList<>();
 
-            // cut the channels
-            PetriNet cuttedNet = cutChannels(petriNet);
+            // cut the service transitions
+            PetriNet serviceCuttedNet = cutServiceTransitions(petriNet);
+
+            // cut the topic transitions
+            PetriNet cuttedNet = cutTopicTransitions(serviceCuttedNet);
             //logger.error("cuttedNet: --------------------------------------------");
             //printNet(cuttedNet);
 
@@ -77,8 +80,8 @@ public class GlobalToLocalNetsPostProcessor implements PostProcessor<PetriNet> {
         Set<String> allLocations = new HashSet<>();
 
         for (Place place : petriNet.allPlaces()) {
-            if (place.asOutputSignalPlace().getPlaceInformation().getSubNet() != null) {
-                allLocations.add(place.asOutputSignalPlace().getPlaceInformation().getSubNet());
+            if (place.asOutputSignalPlace().getStaticTransitionInformation().getSubNet() != null) {
+                allLocations.add(place.asOutputSignalPlace().getStaticTransitionInformation().getSubNet());
             } else {
                 logger.error("Found place without location.");
             }
@@ -86,7 +89,48 @@ public class GlobalToLocalNetsPostProcessor implements PostProcessor<PetriNet> {
         return allLocations;
     }
 
-    private static PetriNet cutChannels(PetriNet petriNet) {
+    private static PetriNet cutServiceTransitions(PetriNet petriNet) {
+
+        Set<Transition> transitionsToAdd = new HashSet<>();
+        Set<Transition> transitionsToRemove = new HashSet<>();
+
+        for (Transition transition : petriNet.allTransitions()) {
+
+            InputSignalTransition channelIst = transition.asInputSignalTransition();
+
+            // just process service transitions
+            if(channelIst.getStaticTransitionInformation().isServiceTransitionInformation()
+                    && channelIst.getStaticTransitionInformation().getType().equals(PnmlConstants.TRANSITION_TYPE_SERVICE_REQUEST)){
+
+                int numInArcs = channelIst.getInArcList().toArray(new Arc[0]).length;
+
+                // STEP 1: Get location/subnet of source/target - places
+                String inLocation = null;
+                String outLocation = null;
+                String inSubNet = null;
+                String outSubNet = null;
+
+                for (Place p : channelIst.incomingPlaces()) {
+                    inLocation = p.asOutputSignalPlace().getStaticTransitionInformation().getLocation();
+                    inSubNet = p.asOutputSignalPlace().getStaticTransitionInformation().getSubNet();
+                    break;
+                }
+
+                for (Place p : channelIst.outgoingPlaces()) {
+                    outLocation = p.asOutputSignalPlace().getStaticTransitionInformation().getLocation();
+                    outSubNet = p.asOutputSignalPlace().getStaticTransitionInformation().getSubNet();
+                    break;
+                }
+
+                // STEP 2: Create new
+            }
+
+        }
+
+        return null;
+    }
+
+    private static PetriNet cutTopicTransitions(PetriNet petriNet) {
 
         //printNet(petriNet);
 
@@ -112,14 +156,14 @@ public class GlobalToLocalNetsPostProcessor implements PostProcessor<PetriNet> {
                 String outSubNet = null;
 
                 for (Place p : channelIst.incomingPlaces()) {
-                    inLocation = p.asOutputSignalPlace().getPlaceInformation().getLocation();
-                    inSubNet = p.asOutputSignalPlace().getPlaceInformation().getSubNet();
+                    inLocation = p.asOutputSignalPlace().getStaticTransitionInformation().getLocation();
+                    inSubNet = p.asOutputSignalPlace().getStaticTransitionInformation().getSubNet();
                     break;
                 }
 
                 for (Place p : channelIst.outgoingPlaces()) {
-                    outLocation = p.asOutputSignalPlace().getPlaceInformation().getLocation();
-                    outSubNet = p.asOutputSignalPlace().getPlaceInformation().getSubNet();
+                    outLocation = p.asOutputSignalPlace().getStaticTransitionInformation().getLocation();
+                    outSubNet = p.asOutputSignalPlace().getStaticTransitionInformation().getSubNet();
                     break;
                 }
 
@@ -229,7 +273,7 @@ public class GlobalToLocalNetsPostProcessor implements PostProcessor<PetriNet> {
         Set<String> removePlaceIds = new HashSet<>();
 
         for (Place place : separatedNet.allPlaces()) {
-            if (!place.asOutputSignalPlace().getPlaceInformation().getSubNet().equals(location)) {
+            if (!place.asOutputSignalPlace().getStaticTransitionInformation().getSubNet().equals(location)) {
                 removePlaceIds.add(place.getId());
             }
         }
@@ -249,7 +293,7 @@ public class GlobalToLocalNetsPostProcessor implements PostProcessor<PetriNet> {
         }
 
         for (Place place : separatedNet.allPlaces()) {
-            if (!place.asOutputSignalPlace().getPlaceInformation().getSubNet().equals(location)) {
+            if (!place.asOutputSignalPlace().getStaticTransitionInformation().getSubNet().equals(location)) {
                 logger.info("removing place " + place.getId() + " from net");
                 place.removeSelf();
             }
@@ -359,71 +403,4 @@ public class GlobalToLocalNetsPostProcessor implements PostProcessor<PetriNet> {
 
         return null;
     }
-
-    public static void printNet(PetriNet petriNet) {
-
-        logger.info("--------------- STRUCTURE ---------------");
-        logger.info("----------------- PLACES ----------------");
-
-        for (Place p : petriNet.allPlaces()) {
-            logger.info("Place " + p.asOutputSignalPlace().getName().getText() + " -- " + p.asOutputSignalPlace().getPlaceInformation().getSubNet());
-        }
-
-        logger.info("-------------- TRANSITIONS --------------");
-
-        for (Transition t : petriNet.allTransitions()) {
-
-            if(t.asInputSignalTransition().getStaticTransitionInformation().isServiceTransitionInformation()) {
-                logger.info("--- Transition: " + t.getName().getText() + " subnet: " + t.asInputSignalTransition().getStaticTransitionInformation().getSubNet()
-                        + " service: " + t.asInputSignalTransition().getStaticTransitionInformation().asServiceTransitionInformation().getServiceName() + " ---------");
-            }else{
-                logger.info("--- Transition: " + t.getName().getText() + " subnet: " + t.asInputSignalTransition().getStaticTransitionInformation().getSubNet()
-                        + " topic: " + t.asInputSignalTransition().getStaticTransitionInformation().asTopicTransitionInformation().getTopic() + " ---------");
-            }
-
-            for (Place p : t.asInputSignalTransition().incomingPlaces()) {
-
-                logger.info("------ Inputplace:  " + p.getName().getText() + " subnet: " + p.asOutputSignalPlace().getPlaceInformation().getSubNet() + " ---------");
-            }
-
-            for (Place p : t.asInputSignalTransition().outgoingPlaces()) {
-
-                logger.info("------ Outputplace: " + p.getName().getText() + " subnet: " + p.asOutputSignalPlace().getPlaceInformation().getSubNet() + " ---------");
-            }
-        }
-
-        logger.info("----------------- ARCS -----------------");
-
-        for (Arc a : petriNet.allArcs()) {
-
-            logger.info("Arc: " + a.getId() + " -- source: " + a.getSource().getName().getText() + " -- target: " + a.getTarget().getName().getText());
-        }
-
-        logger.info("--------------- T SIGNALS (STATIC)---------------");
-
-        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()));
-            }
-        }
-
-        logger.info("--------------- T SIGNALS (MUTUAL)---------------");
-
-        for (Transition t : petriNet.allTransitions()) {
-            InputSignalTransition ist = t.asInputSignalTransition();
-
-            if (ist != null && ist.getMutualInputSignalBindingList() != null) {
-                ist.getMutualInputSignalBindingList().forEach(inputSignalBinding -> logger.info(" (" + t.getName().getText() + ") Signal: " + inputSignalBinding.getInputSignalID()));
-            }
-        }
-
-        logger.info("--------------- TOOL SPECIFIC ---------------");
-
-        for (Transition t : petriNet.allTransitions()) {
-            InputSignalTransition ist = t.asInputSignalTransition();
-            logger.info("ToolSpecific: (" + ist.getName().getText() + ") " + ist.getToolspecific(0).getFormattedXMLBuffer().toString());
-        }
-    }
 }

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

+package de.tudresden.inf.st.postprocessing;
+
+import de.tudresden.inf.st.constants.PnmlConstants;
+import de.tudresden.inf.st.pnml.jastadd.model.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class PostProcessingUtils {
+
+    private static final Logger logger = LoggerFactory.getLogger(PostProcessingUtils.class);
+
+    ///////////////////////////////
+    // NET INFORMATION ////////////
+    ///////////////////////////////
+
+    private static Set<Transition> getTransitionsBySubnet(String subNet, PetriNet petriNet){
+
+        return petriNet.allTransitions().stream().filter(t -> t.asInputSignalTransition()
+                .getStaticTransitionInformation().getSubNet().equals(subNet)).collect(Collectors.toSet());
+    }
+
+    private static Set<String> getTransitionIDsBySubnet(String subNet, PetriNet petriNet){
+
+        Set<String> transitionIds = new HashSet<>();
+
+        for(Transition t : getTransitionsBySubnet(subNet, petriNet)){
+            transitionIds.add(t.getId());
+        }
+
+        return transitionIds;
+    }
+
+    private static Set<String> getPlaceIDsBySubnet(String subNet, PetriNet petriNet){
+
+        Set<String> placeIds = new HashSet<>();
+
+        for(Place p : getPlacesBySubnet(subNet, petriNet)){
+            placeIds.add(p.getId());
+        }
+
+        return placeIds;
+    }
+
+    private static Set<Place> getPlacesBySubnet(String subNet, PetriNet petriNet){
+
+        return petriNet.allPlaces().stream().filter(t -> t.asOutputSignalPlace()
+                .getStaticTransitionInformation().getSubNet().equals(subNet)).collect(Collectors.toSet());
+    }
+
+    private static Set<Arc> getInternalArcsBySubnet(String subNet, PetriNet petriNet){
+
+        Set<Arc> internalArcs = new HashSet<>();
+        Set<String> subNetTransitionIds = getTransitionIDsBySubnet(subNet, petriNet);
+        Set<String> subNetPlaceIds = getPlaceIDsBySubnet(subNet, petriNet);
+
+
+        for(Arc arc : petriNet.allArcs()){
+            if((subNetTransitionIds.contains(arc.getSource().getId()) && subNetPlaceIds.contains(arc.getTarget().getId()))
+                    || (subNetTransitionIds.contains(arc.getTarget().getId()) && subNetPlaceIds.contains(arc.getSource().getId()))){
+                internalArcs.add(arc);
+            }
+        }
+
+        return internalArcs;
+    }
+
+    private static Set<Arc> getExternalArcsBySubnet(String subNet, PetriNet petriNet){
+
+        Set<Arc> externalArcs = new HashSet<>();
+        Set<String> subNetTransitionIds = getTransitionIDsBySubnet(subNet, petriNet);
+        Set<String> subNetPlaceIds = getPlaceIDsBySubnet(subNet, petriNet);
+
+        for(Arc arc : petriNet.allArcs()){
+            if(subNetTransitionIds.contains(arc.getSource().getId()) || subNetPlaceIds.contains(arc.getTarget().getId())
+                    || subNetTransitionIds.contains(arc.getTarget().getId()) || subNetPlaceIds.contains(arc.getSource().getId())){
+                externalArcs.add(arc);
+            }
+        }
+
+        return externalArcs;
+    }
+
+    ///////////////////////////////
+    // NET MANIPULATION ///////////
+    ///////////////////////////////
+
+    public static void setSubNetInstanceId(PetriNet petriNet, String subNet, String instanceId){
+
+        Set<Transition> subNetTransitions = getTransitionsBySubnet(subNet, petriNet);
+        Set<Place> subNetPlaces = getPlacesBySubnet(subNet, petriNet);
+
+        subNetTransitions.forEach(t -> {
+
+            if(t.asInputSignalTransition().getMutualTransitionInformation() == null){
+                // todo
+                t.asInputSignalTransition().getMutualTransitionInformation().setInstance(instanceId);
+            }
+        });
+        //subNetPlaces.forEach(p -> p.asOutputSignalPlace());
+
+    }
+
+    public static PetriNet copySubNet(PetriNet petriNet, String subNet, String instanceId){
+
+        Set<Transition> transitionsToAdd = new HashSet<>();
+        Set<Place> placesToRemove = new HashSet<>();
+        Set<Arc> arcsToRemove = new HashSet<>();
+
+
+
+
+
+        for (Transition transition : petriNet.allTransitions()) {
+
+            InputSignalTransition channelIst = transition.asInputSignalTransition();
+
+            // just process service transitions
+            if(channelIst.getStaticTransitionInformation().isServiceTransitionInformation()
+                    && channelIst.getStaticTransitionInformation().getType().equals(PnmlConstants.TRANSITION_TYPE_SERVICE_REQUEST)){
+
+                int numInArcs = channelIst.getInArcList().toArray(new Arc[0]).length;
+            }
+
+        }
+        return null;
+    }
+
+    ///////////////////////////////
+    // LOGGING ////////////////////
+    ///////////////////////////////
+
+    public static void printNet(PetriNet petriNet) {
+
+        logger.info("--------------- STRUCTURE ---------------");
+        logger.info("----------------- PLACES ----------------");
+
+        for (Place p : petriNet.allPlaces()) {
+            logger.info("Place " + p.asOutputSignalPlace().getName().getText() + " -- " + p.asOutputSignalPlace().getStaticTransitionInformation().getSubNet());
+        }
+
+        logger.info("-------------- TRANSITIONS --------------");
+
+        for (Transition t : petriNet.allTransitions()) {
+
+            if(t.asInputSignalTransition().getStaticTransitionInformation().isServiceTransitionInformation()) {
+                logger.info("--- Transition: " + t.getName().getText() + " subnet: " + t.asInputSignalTransition().getStaticTransitionInformation().getSubNet()
+                        + " service: " + t.asInputSignalTransition().getStaticTransitionInformation().asServiceTransitionInformation().getServiceName() + " ---------");
+            }else{
+                logger.info("--- Transition: " + t.getName().getText() + " subnet: " + t.asInputSignalTransition().getStaticTransitionInformation().getSubNet()
+                        + " topic: " + t.asInputSignalTransition().getStaticTransitionInformation().asTopicTransitionInformation().getTopic() + " ---------");
+            }
+
+            for (Place p : t.asInputSignalTransition().incomingPlaces()) {
+
+                logger.info("------ Inputplace:  " + p.getName().getText() + " subnet: " + p.asOutputSignalPlace().getStaticTransitionInformation().getSubNet() + " ---------");
+            }
+
+            for (Place p : t.asInputSignalTransition().outgoingPlaces()) {
+
+                logger.info("------ Outputplace: " + p.getName().getText() + " subnet: " + p.asOutputSignalPlace().getStaticTransitionInformation().getSubNet() + " ---------");
+            }
+        }
+
+        logger.info("----------------- ARCS -----------------");
+
+        for (Arc a : petriNet.allArcs()) {
+
+            logger.info("Arc: " + a.getId() + " -- source: " + a.getSource().getName().getText() + " -- target: " + a.getTarget().getName().getText());
+        }
+
+        logger.info("--------------- T SIGNALS (STATIC)---------------");
+
+        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()));
+            }
+        }
+
+        logger.info("--------------- T SIGNALS (MUTUAL)---------------");
+
+        for (Transition t : petriNet.allTransitions()) {
+            InputSignalTransition ist = t.asInputSignalTransition();
+
+            if (ist != null && ist.getMutualInputSignalBindingList() != null) {
+                ist.getMutualInputSignalBindingList().forEach(inputSignalBinding -> logger.info(" (" + t.getName().getText() + ") Signal: " + inputSignalBinding.getInputSignalID()));
+            }
+        }
+
+        logger.info("--------------- TOOL SPECIFIC ---------------");
+
+        for (Transition t : petriNet.allTransitions()) {
+            InputSignalTransition ist = t.asInputSignalTransition();
+            logger.info("ToolSpecific: (" + ist.getName().getText() + ") " + ist.getToolspecific(0).getFormattedXMLBuffer().toString());
+        }
+    }
+}