← Back to branch summary

~sgaflv/workcraft/trunk-interfaces

« back to all changes in this revision

Viewing changes to SONPlugin/src/org/workcraft/plugins/son/verify/CSONStructureTask.java

  • Committer: Stan
  • Date: 2014-09-02 13:08:40 UTC
  • mfrom: (517.1.24 workcraft-trunk)
  • Revision ID: sgaflv@gmail.com-20140902130840-x5zqoha2vi2934qq
- merge with the main branch

Show diffs side-by-side

added added

removed removed

Lines of Context:
SONPlugin/src/org/workcraft/plugins/son/verify/CSONStructureTask.java
2
2
 
3
3
import java.util.ArrayList;
4
4
import java.util.Collection;
 
5
import java.util.HashSet;
5
6
 
6
7
import org.apache.log4j.Logger;
7
8
import org.workcraft.dom.Node;
8
9
import org.workcraft.plugins.son.ONGroup;
9
10
import org.workcraft.plugins.son.SONModel;  
10
 
import org.workcraft.plugins.son.SONSettings;
11
 
import org.workcraft.plugins.son.algorithm.CSONPathAlg;
12
 
import org.workcraft.plugins.son.algorithm.RelationAlgorithm;
13
11
import org.workcraft.plugins.son.elements.ChannelPlace;
14
12
 
15
13
 
16
 
public class CSONStructureTask implements StructuralVerification{
 
14
public class CSONStructureTask extends AbstractStructuralVerification{
17
15
 
18
16
        private SONModel net;
19
17
        private Logger logger = Logger.getLogger(this.getClass().getName());
20
18
        
21
 
        private RelationAlgorithm relationAlg;
22
 
        private CSONPathAlg csonPathAlg;
23
 
        
24
 
        private Collection<ChannelPlace> cPlaceResult = new ArrayList<ChannelPlace>();
25
 
        private Collection<ChannelPlace> cPlaceConTypeResult =  new ArrayList<ChannelPlace>();
26
 
        private Collection<ArrayList<Node>> cycleResult = new ArrayList<ArrayList<Node>>();
27
 
//      private Collection<List<ChannelPlace>> cPlaceStructureResult;
 
19
        private Collection<Node> relationErrors = new ArrayList<Node>();
 
20
        private Collection<ArrayList<Node>> cycleErrors = new ArrayList<ArrayList<Node>>();
 
21
        private Collection<ONGroup> groupErrors = new HashSet<ONGroup>();
28
22
        
29
23
        private boolean hasErr = false;
30
24
        private int errNumber = 0;
31
25
        private int warningNumber = 0;
32
26
 
33
27
        public CSONStructureTask(SONModel net){         
 
28
                super(net);
34
29
                this.net = net; 
35
 
                relationAlg = new RelationAlgorithm(net);
36
 
                csonPathAlg = new CSONPathAlg(net);
37
30
        }
38
31
        
39
32
        public void task(Collection<ONGroup> groups){
51
44
                logger.info("Group Components = " + components.size());
52
45
                        
53
46
                ArrayList<ChannelPlace> relatedcPlaces = new ArrayList<ChannelPlace>();
54
 
                relatedcPlaces.addAll(relationAlg.getRelatedChannelPlace(groups));      
 
47
                relatedcPlaces.addAll(getRelationAlg().getRelatedChannelPlace(groups)); 
55
48
                components.addAll(relatedcPlaces);
56
49
                
57
50
                logger.info("Channel Place(s) = " + relatedcPlaces.size());
63
56
                
64
57
                //channel place relation
65
58
                logger.info("Running model structure and components relation check...");
66
 
                cPlaceResult.addAll(cPlaceRelationTask(relatedcPlaces));
67
 
                cPlaceConTypeResult.addAll(cPlaceConTypeTask(relatedcPlaces)); 
 
59
                Collection<ChannelPlace> task1 = cPlaceRelationTask(relatedcPlaces);
 
60
                Collection<ChannelPlace> task2 = cPlaceConTypeTask(relatedcPlaces);
 
61
                relationErrors.addAll(task1);
 
62
                relationErrors.addAll(task2); 
68
63
                
69
 
                if(cPlaceResult.isEmpty() && cPlaceConTypeResult.isEmpty())
 
64
                if(relationErrors.isEmpty() && relationErrors.isEmpty())
70
65
                        logger.info("Correct channel place relation.");
71
66
                else{
72
67
                        hasErr = true;
73
 
                        errNumber = errNumber + cPlaceResult.size() + cPlaceConTypeResult.size();
74
 
                        for(ChannelPlace cPlace : cPlaceResult)
 
68
                        errNumber = errNumber + relationErrors.size();
 
69
                        for(Node cPlace : task1)
75
70
                                logger.error("ERROR : Incorrect channel place relation: " + net.getName(cPlace) + "(" + net.getComponentLabel(cPlace) + ")  : " +
76
71
                                                "input/output size > 1");
77
72
                                        
78
 
                        for(ChannelPlace cPlace : cPlaceConTypeResult)
 
73
                        for(Node cPlace : task2)
79
74
                                logger.error("ERROR : Incorrect communication types: " + net.getName(cPlace) + "(" + net.getComponentLabel(cPlace) + ")  :" +
80
75
                                                "different input and output connection types");
81
76
                }       
101
96
                
102
97
                //global cycle detection
103
98
                logger.info("Running cycle detection...");
104
 
                cycleResult.addAll(csonPathAlg.cycleTask(components));
 
99
                cycleErrors.addAll(getCSONPathAlg().cycleTask(components));
105
100
                
106
 
                if (cycleResult.isEmpty() )
 
101
                if (cycleErrors.isEmpty() )
107
102
                        logger.info("Acyclic structure correct");
108
103
                else{
109
104
                        hasErr = true;
110
105
                        errNumber++;
111
 
                        logger.error("ERROR : global cycles = "+ cycleResult.size() + ".");   
 
106
                        logger.error("ERROR : global cycles = "+ cycleErrors.size() + ".");   
112
107
                }
113
108
                
114
109
                logger.info("Cycle detection complete.\n");
212
207
                return result;
213
208
        }*/
214
209
        
215
 
        public void errNodesHighlight(){
216
 
                
217
 
                for(ChannelPlace cPlace : cPlaceResult){
218
 
                        this.net.setFillColor(cPlace, SONSettings.getRelationErrColor());
219
 
                }
220
 
                
221
 
                for(ChannelPlace cPlace : cPlaceConTypeResult){
222
 
                        this.net.setFillColor(cPlace, SONSettings.getRelationErrColor());
223
 
                }
224
 
                
225
 
/*              for(List<ChannelPlace> list : cPlaceStructureResult)
226
 
                        for(ChannelPlace cPlace : list)
227
 
                        this.net.setFillColor(cPlace, SONSettings.getRelationErrColor());*/
228
 
                
229
 
                
230
 
                for (ArrayList<Node> list : this.cycleResult)
231
 
                        for (Node node : list)
232
 
                                this.net.setForegroundColor(node, SONSettings.getCyclePathColor());
 
210
        @Override
 
211
        public Collection<String> getRelationErrors() {
 
212
                return getRelationErrorsSetReferences(relationErrors);
 
213
        }
 
214
 
 
215
        @Override
 
216
        public Collection<ArrayList<String>> getCycleErrors() {
 
217
                return getcycleErrorsSetReferences(cycleErrors);
 
218
        }
 
219
 
 
220
        @Override
 
221
        public Collection<String> getGroupErrors() {
 
222
                return getGroupErrorsSetReferences(groupErrors);
233
223
        }
234
224
        
 
225
        @Override
235
226
        public boolean hasErr(){
236
227
                return this.hasErr;
237
228
        }
238
229
        
 
230
        @Override
239
231
        public int getErrNumber(){
240
232
                return this.errNumber;
241
233
        }
242
234
        
 
235
        @Override
243
236
        public int getWarningNumber(){
244
237
                return this.warningNumber;
245
238
        }