-
Notifications
You must be signed in to change notification settings - Fork 0
/
NotatedState.java
180 lines (165 loc) · 4.63 KB
/
NotatedState.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
package siteswapsuite;
import java.util.regex.Pattern;
public abstract class NotatedState {
State state;
StateNotation notationType;
private NotatedState(int numHands) {
this.state = new State(numHands);
this.notationType = null; //???
}
public static NotatedState parse(String inputNotation, int numHands, int startHand) throws InvalidStateNotationException, IncompatibleNumberOfHandsException {
// determine type of notation
StateNotation notationType = StateNotation.analyze(inputNotation);
if(notationType == StateNotation.SIMPLE) {
if(numHands == 1 || numHands == -1) {
return new SimpleNotatedState(inputNotation);
} else {
throw new IncompatibleNumberOfHandsException();
}
} else if(notationType == StateNotation.COMPLEX) {
Util.printf("ERROR: complex state notation parsing not yet supported!", Util.DebugLevel.ERROR);
System.exit(1);
return null;
// return new ComplexNotatedState(inputNotation);
} else {
throw new InvalidStateNotationException(inputNotation);
}
}
public static NotatedState assembleAutomatic(State state) {
try {
return assemble(state, StateNotation.defaultNotationType(state.numHands()));
} catch(IncompatibleNumberOfHandsException e) {
Util.printf("ERROR: impossible error in NotatedState.assembleAutomatic", Util.DebugLevel.ERROR);
System.exit(1);
return null;
}
}
public static NotatedState assemble(State state, StateNotation notationType) throws IncompatibleNumberOfHandsException {
NotatedState ret;
if(notationType == StateNotation.SIMPLE) {
ret = new SimpleNotatedState();
ret.state = state;
} else {
ret = new ComplexNotatedState();
ret.state = state;
}
return ret;
}
public abstract NotatedState deepCopy();
/* -------------- */
/* THE SUBCLASSES */
/* -------------- */
private static class SimpleNotatedState extends NotatedState {
SimpleNotatedState() {
super(1);
this.notationType = StateNotation.SIMPLE;
}
SimpleNotatedState(State state) {
this();
this.state = state;
}
SimpleNotatedState(String s) {
this();
State.Node curNode = this.state.nowNode;
char[] a = s.toCharArray();
int i = 0;
boolean isNegative = false;
this.state.repeatedLength = 0;
while(i < a.length) {
switch(a[i]) {
case '-':
isNegative = true;
break;
default:
this.state.finiteLength++;
State.Node newNode = this.state.new Node();
if(this.state.nowNode == null) {
this.state.nowNode = newNode;
curNode = state.nowNode;
} else {
curNode.prev = newNode;
curNode = newNode;
}
ExtendedInteger h = SiteswapNotation.throwHeight(a[i]);
if(isNegative)
h.negate();
curNode.setChargeAtHand(0, h.finiteValue()); // h is always finite, given what chars we're giving to throwHeight
isNegative = false;
break;
}
i++;
}
// TODO: non-finite state parsing
}
public NotatedState deepCopy() {
return new SimpleNotatedState(this.state.deepCopy());
}
}
private static class ComplexNotatedState extends NotatedState {
ComplexNotatedState() {
super(2);
this.notationType = StateNotation.COMPLEX;
}
ComplexNotatedState(State state) {
this();
this.state = state;
}
ComplexNotatedState(String s) {
this();
boolean isNegative = false;
State.Node curNode = this.state.nowNode;
char[] a = s.toCharArray();
int i = 0;
boolean seenComma = false;
this.state.repeatedLength = 0;
while(i < a.length) {
switch(a[i]) {
case '(':
this.state.finiteLength++;
State.Node newNode = this.state.new Node();
if(this.state.nowNode == null) {
this.state.nowNode = newNode;
curNode = this.state.nowNode;
} else {
curNode.prev = newNode;
curNode = newNode;
}
seenComma = false;
break;
case ',':
seenComma = true;
break;
case ')':
break;
case '-':
isNegative = true;
break;
default:
ExtendedInteger h = SiteswapNotation.throwHeight(a[i]);
if(isNegative)
h.negate();
if(!seenComma)
curNode.setChargeAtHand(0,h.finiteValue());
else
curNode.setChargeAtHand(1,h.finiteValue());
isNegative = false;
}
i++;
}
}
public NotatedState deepCopy() {
return new ComplexNotatedState(this.state.deepCopy());
}
}
public String print() {
return "[not yet implemented]";
}
public static void main(String[] args) {
try {
NotatedState ns = NotatedState.parse(args[0], -1, -1);
System.out.println(ns);
} catch(InvalidStateNotationException | IncompatibleNumberOfHandsException e) {
System.out.println(e.getMessage());
}
}
}