Package: DefinitionOptState

DefinitionOptState

name	instruction	branch	complexity	line	method
DefinitionOptState()	M: 0 C: 3 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 1 100%	M: 0 C: 1 100%
parse(RouterSoftware, TempVariableDefinition, Buffer, DefinitionFileParser)	M: 16 C: 69 81%	M: 1 C: 3 75%	M: 1 C: 2 67%	M: 2 C: 17 89%	M: 0 C: 1 100%

Coverage

1: package parser.states.definitionstates;
2:
3: import model.RouterSoftware;
4: import model.definition.HasOpt;
5: import model.definition.HasnotOpt;
6: import model.definition.Opt;
7: import parser.DefinitionFileParser;
8: import parser.ParserException;
9: import parser.tempparserobjects.TempVariableDefinition;
10: import symbols.AbstractSymbol;
11: import symbols.EmptySymbol;
12: import symbols.IdentifierSymbol;
13: import basic.Buffer;
14:
15: /**
16: *
17: * @author Muri
18: *
19: */
20: public class DefinitionOptState extends AbstractDefinitionState {
21:
22:         /**
23:          *
24:          * @param tVD
25:          * TempVariableDefinition
26:          * @param dFP
27:          * DefinitionFileParser
28:          * @param buffer
29:          * Buffer<Symbol>
30:          * @return
31:          * @throws InterruptedException
32:          * InterruptedException
33:          * @throws ParserException
34:          * ParserException
35:          */
36:         @Override
37:         public void parse(final RouterSoftware rs, final TempVariableDefinition tVD,
38:                         final Buffer<AbstractSymbol> buffer, final DefinitionFileParser dFP)
39:                         throws InterruptedException, ParserException {
40:                 final AbstractSymbol nextSymbol = buffer.peek();
41:•                if (nextSymbol instanceof EmptySymbol) {
42:                         tVD.setVariableOptReference(new HasnotOpt());
43:                         dFP.setState(new DefinitionVariableNState());
44:                         buffer.remove();
45:•                } else if (nextSymbol instanceof IdentifierSymbol) {
46:                         final Opt newOpt =
47:                                         new Opt(((IdentifierSymbol) nextSymbol).getText(), dFP
48:                                                         .getVariableDefinitionList().get(
49:                                                                         ((IdentifierSymbol) nextSymbol).getText()));
50:                         dFP.getOptList().put(((IdentifierSymbol) nextSymbol).getText(), newOpt);
51:
52:                         dFP.getVariableDefinitionList().get(((IdentifierSymbol) nextSymbol).getText());
53:                         tVD.setVariableOptReference(new HasOpt(newOpt));
54:                         dFP.setState(new DefinitionVariableNState());
55:                         buffer.remove();
56:                 } else {
57:                         throw new ParserException("no valid symbol: "
58:                                         + buffer.peek().getClass().getCanonicalName());
59:                 }
60:         }
61: }