Method: isSymbol(char)

1: package de.fhdw.wtf.dsl.scanner.modelScanner.state;
2:
3: import de.fhdw.wtf.common.stream.TokenStream;
4: import de.fhdw.wtf.common.token.Position;
5: import de.fhdw.wtf.common.token.symbols.ArrowToken;
6: import de.fhdw.wtf.common.token.symbols.AsteriskToken;
7: import de.fhdw.wtf.common.token.symbols.BracketCloseToken;
8: import de.fhdw.wtf.common.token.symbols.BracketOpenToken;
9: import de.fhdw.wtf.common.token.symbols.ColonToken;
10: import de.fhdw.wtf.common.token.symbols.CommaToken;
11: import de.fhdw.wtf.common.token.symbols.CurlyBracketCloseToken;
12: import de.fhdw.wtf.common.token.symbols.CurlyBracketOpenToken;
13: import de.fhdw.wtf.common.token.symbols.DoubleSquareBracketCloseToken;
14: import de.fhdw.wtf.common.token.symbols.DoubleSquareBracketOpenToken;
15: import de.fhdw.wtf.common.token.symbols.EqualToken;
16: import de.fhdw.wtf.common.token.symbols.ExclamationToken;
17: import de.fhdw.wtf.common.token.symbols.GreaterSymbolToken;
18: import de.fhdw.wtf.common.token.symbols.HyphenToken;
19: import de.fhdw.wtf.common.token.symbols.PipeToken;
20: import de.fhdw.wtf.common.token.symbols.PlusSymbolToken;
21: import de.fhdw.wtf.common.token.symbols.SemicolonToken;
22: import de.fhdw.wtf.common.token.symbols.SquareBracketCloseToken;
23: import de.fhdw.wtf.common.token.symbols.SquareBracketOpenToken;
24: import de.fhdw.wtf.common.token.symbols.SymbolConstants;
25:
26: /**
27: * Default state of the Scanner. Recognizes single-char elements(=Symbols) by itself and (otherwise) delegates
28: * processing to appropriate states.
29: */
30: public class SymbolState extends MultiCharState {
31:         
32:         /**
33:          * <b>PRIVATE</b> Constructor.
34:          *
35:          * @param currentInput
36:          * initial symbol
37:          * @param firstPosition
38:          * of the first char.
39:          */
40:         protected SymbolState(final String currentInput, final Position firstPosition) {
41:                 super(currentInput, firstPosition);
42:         }
43:         
44:         /**
45:          * Factory for {@link SymbolState}.
46:          *
47:          * @param firstPosition
48:          * first Position of the first char
49:          * @return {@link SymbolState}
50:          */
51:         public static SymbolState create(final Position firstPosition) {
52:                 return new SymbolState("", firstPosition);
53:         }
54:         
55:         @Override
56:         public void finish(final TokenStream outputStream) {
57:                 final int inputLength = this.getCurrentInput().length();
58:                 final StringBuilder symbols = new StringBuilder(this.getCurrentInput());
59:                 while (symbols.length() > 0) {
60:                         
61:                         // calculate start position
62:                         final Position position =
63:                                         this.calculateNewPosition(this.getFirstPosition(), inputLength - symbols.length());
64:                         
65:                         final String sign = Character.toString(symbols.charAt(0));
66:                         symbols.deleteCharAt(0);
67:                         if (sign.equals(SymbolConstants.EQUALS)) {
68:                                 outputStream.add(EqualToken.create(position));
69:                         } else if (sign.equals(SymbolConstants.CURLYBRACKETCLOSE)) {
70:                                 outputStream.add(CurlyBracketCloseToken.create(position));
71:                         } else if (sign.equals(SymbolConstants.CURLYBRACKETOPEN)) {
72:                                 outputStream.add(CurlyBracketOpenToken.create(position));
73:                         } else if (sign.equals(SymbolConstants.ASTERISK)) {
74:                                 outputStream.add(AsteriskToken.create(position));
75:                         } else if (sign.equals(SymbolConstants.SEMICOLON)) {
76:                                 outputStream.add(SemicolonToken.create(position));
77:                         } else if (sign.equals(SymbolConstants.GREATERSYMBOL)) {
78:                                 outputStream.add(GreaterSymbolToken.create(position));
79:                         } else if (sign.equals(SymbolConstants.PLUS)) {
80:                                 outputStream.add(PlusSymbolToken.create(position));
81:                         } else if (sign.equals(SymbolConstants.COLON)) {
82:                                 outputStream.add(ColonToken.create(position));
83:                         } else if (sign.equals(SymbolConstants.PIPE)) {
84:                                 outputStream.add(PipeToken.create(position));
85:                         } else if (sign.equals(SymbolConstants.BRACKETOPEN)) {
86:                                 outputStream.add(BracketOpenToken.create(position));
87:                         } else if (sign.equals(SymbolConstants.BRACKETCLOSE)) {
88:                                 outputStream.add(BracketCloseToken.create(position));
89:                         } else if (sign.equals(SymbolConstants.COMMA)) {
90:                                 outputStream.add(CommaToken.create(position));
91:                         } else if (sign.equals(SymbolConstants.EXCLAMATION)) {
92:                                 outputStream.add(ExclamationToken.create(position));
93:                         } else if (sign.equals(SymbolConstants.SQUAREBRACKETOPEN)) {
94:                                 // Check for SquareBracketOpen on next position
95:                                 if (symbols.length() > 0
96:                                                 && Character.toString(symbols.charAt(0)).equals(SymbolConstants.SQUAREBRACKETOPEN)) {
97:                                         outputStream.add(DoubleSquareBracketOpenToken.create(position));
98:                                         symbols.deleteCharAt(0);
99:                                 } else {
100:                                         outputStream.add(SquareBracketOpenToken.create(position));
101:                                 }
102:                         } else if (sign.equals(SymbolConstants.SQUAREBRACKETCLOSE)) {
103:                                 // Check for SquareBracketClose on next position
104:                                 if (symbols.length() > 0
105:                                                 && Character.toString(symbols.charAt(0)).equals(SymbolConstants.SQUAREBRACKETCLOSE)) {
106:                                         outputStream.add(DoubleSquareBracketCloseToken.create(position));
107:                                         symbols.deleteCharAt(0);
108:                                 } else {
109:                                         outputStream.add(SquareBracketCloseToken.create(position));
110:                                 }
111:                         } else if (sign.equals(SymbolConstants.HYPHEN)) {
112:                                 if (symbols.length() > 0 && Character.toString(symbols.charAt(0)).equals(SymbolConstants.GREATERSYMBOL)) {
113:                                         outputStream.add(ArrowToken.create(position));
114:                                         symbols.deleteCharAt(0);
115:                                 } else {
116:                                         outputStream.add(HyphenToken.create(position));
117:                                 }
118:                         }
119:                 }
120:         }
121:         
122:         private Position calculateNewPosition(final Position oldPosition, final int count) {
123:                 final int lineNumber = oldPosition.getLineNumber();
124:                 final int columnNumber = oldPosition.getColumnNumber() + count;
125:                 final int p = oldPosition.getPosition() + count;
126:                 final String filePath = oldPosition.getFilePath();
127:                 return Position.create(filePath, lineNumber, columnNumber, p);
128:         }
129:         
130:         /**
131:          * Tests <code>input</code> as symbol of <b>WTF-DSL</b>.
132:          *
133:          * @param input
134:          * Character to test
135:          * @return <code>true</code> if <code>input</code> is a symbol of the <b>WTF-DSL</b> <br>
136:          * <code>false</code> if <code>input</code> is <b>not</b> a symbol of the <b>WTF-DSL</b>
137:          */
138:         public static boolean isSymbol(final char input) {
139:                 final String inputValue = String.valueOf(input);
140:•                return inputValue.equals(SymbolConstants.EQUALS) || inputValue.equals(SymbolConstants.CURLYBRACKETCLOSE)
141:•                                || inputValue.equals(SymbolConstants.CURLYBRACKETOPEN) || inputValue.equals(SymbolConstants.ASTERISK)
142:•                                || inputValue.equals(SymbolConstants.SEMICOLON)
143:•                                || inputValue.equals(SymbolConstants.SQUAREBRACKETCLOSE)
144:•                                || inputValue.equals(SymbolConstants.SQUAREBRACKETOPEN)
145:•                                || inputValue.equals(SymbolConstants.GREATERSYMBOL) || inputValue.equals(SymbolConstants.PLUS)
146:•                                || inputValue.equals(SymbolConstants.COLON) || inputValue.equals(SymbolConstants.HYPHEN)
147:•                                || inputValue.equals(SymbolConstants.PIPE) || inputValue.equals(SymbolConstants.BRACKETOPEN)
148:•                                || inputValue.equals(SymbolConstants.BRACKETCLOSE) || inputValue.equals(SymbolConstants.COMMA)
149:•                                || inputValue.equals(SymbolConstants.EXCLAMATION);
150:         }
151:         
152:         @Override
153:         public boolean accept(final ScannerStateVisitor visitor) {
154:                 return visitor.handleSymbolState();
155:         }
156: }