Package: VariableState

VariableState

name	instruction	branch	complexity	line	method
VariableState(PackageDescriptionFileParser)	M: 0 C: 4 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 2 100%	M: 0 C: 1 100%
action(RouterSoftware, PackageDescriptionFileSymbol)	M: 28 C: 66 70%	M: 4 C: 6 60%	M: 3 C: 3 50%	M: 3 C: 17 85%	M: 0 C: 1 100%
splitContent(String)	M: 0 C: 43 100%	M: 0 C: 2 100%	M: 0 C: 2 100%	M: 0 C: 9 100%	M: 0 C: 1 100%

Coverage

1: package parser.states.packagestates;
2:
3: import java.util.ArrayList;
4: import java.util.Iterator;
5: import java.util.List;
6:
7: import model.RouterSoftware;
8: import model.definition.AbstractVariableDefinition;
9: import parser.PackageDescriptionFileParser;
10: import parser.ParserConstants;
11: import parser.ParserException;
12: import parser.TempPackageRule;
13: import scanner.ScannerConstants;
14: import symbols.PackageDescriptionFileSymbol;
15:
16: /**
17: * This class represent the VariableState for the Scanner.
18: *
19: * @author HFW410
20: *
21: */
22: public class VariableState extends AbstractPackageParserState {
23:         /**
24:          * This constructor initialize the variable State.
25:          *
26:          * @param parser
27:          * is the packageDescriptionFileParser
28:          */
29:         public VariableState(final PackageDescriptionFileParser parser) {
30:                 super(parser);
31:         }
32:
33:         @Override
34:         public AbstractPackageParserState action(final RouterSoftware rs,
35:                         final PackageDescriptionFileSymbol symbol)
36:                         throws ParserException, InterruptedException {
37:                 final AbstractPackageParserState state;
38:                 final TempPackageRule tempPackageRule = new TempPackageRule();
39:                 tempPackageRule.setPosition(symbol.getPosition());
40:                 final String content = symbol.toVariableSymbol().getContent();
41:•                if (content.equalsIgnoreCase(ParserConstants.OPT_FORMAT_VERSION)) {
42:                         this.getMyParser().skip();
43:                         state = new FormatVersionState(this.getMyParser());
44:                 } else {
45:                         final List<String> strings = this.splitContent(content);
46:•                        for (final Iterator<String> iterator = strings.iterator(); iterator.hasNext();) {
47:                                 final String string = iterator.next().toUpperCase();
48:                                 AbstractVariableDefinition aVD = rs.findDefinition(string);
49:•                                if (aVD == null) {
50:                                         aVD = rs.findDefinition("OPT_" + string);
51:                                 }
52:•                                if (aVD != null) {
53:                                         tempPackageRule.addVariable(aVD);
54:•                                } else if (!rs.getWeakList().containsKey(string)) {
55:                                         throw new ParserException("VariableDefinition not found for " + string);
56:                                 }
57:                         }
58:                         this.getMyParser().skip();
59:                         state = new ValueState(this.getMyParser(), tempPackageRule);
60:                 }
61:                 return state;
62:         }
63:
64:         /**
65:          * Splitts a comma seperated List in it's parts.
66:          *
67:          * @param content
68:          * the List of Strings
69:          * @return the List of Strings without commas
70:          */
71:         private List<String> splitContent(final String content) {
72:                 final List<String> strings = new ArrayList<String>();
73:                 String part = content;
74:                 Integer position = part.indexOf(ScannerConstants.COMMA);
75:•                while (position > 0) {
76:                         strings.add(part.substring(0, position));
77:                         part = part.substring(position + 1);
78:                         position = part.indexOf(ScannerConstants.COMMA);
79:                 }
80:                 strings.add(part);
81:                 return strings;
82:         }
83: }