1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.orekit.files.ccsds.ndm.tdm;
18
19 import java.util.ArrayList;
20 import java.util.List;
21 import java.util.function.Function;
22
23 import org.orekit.data.DataContext;
24 import org.orekit.files.ccsds.ndm.ParsedUnitsBehavior;
25 import org.orekit.files.ccsds.section.HeaderProcessingState;
26 import org.orekit.files.ccsds.section.KvnStructureProcessingState;
27 import org.orekit.files.ccsds.section.MetadataKey;
28 import org.orekit.files.ccsds.section.Segment;
29 import org.orekit.files.ccsds.section.XmlStructureProcessingState;
30 import org.orekit.files.ccsds.utils.ContextBinding;
31 import org.orekit.files.ccsds.utils.FileFormat;
32 import org.orekit.files.ccsds.utils.lexical.ParseToken;
33 import org.orekit.files.ccsds.utils.parsing.AbstractConstituentParser;
34 import org.orekit.files.ccsds.utils.parsing.ProcessingState;
35 import org.orekit.utils.IERSConventions;
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59 public class TdmParser extends AbstractConstituentParser<TdmHeader, Tdm, TdmParser> {
60
61
62 private final RangeUnitsConverter converter;
63
64
65 private TdmMetadata metadata;
66
67
68 private ContextBinding context;
69
70
71 private ObservationsBlock observationsBlock;
72
73
74 private TdmHeader header;
75
76
77 private List<Segment<TdmMetadata, ObservationsBlock>> segments;
78
79
80 private ProcessingState structureProcessor;
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97 public TdmParser(final IERSConventions conventions, final boolean simpleEOP, final DataContext dataContext,
98 final ParsedUnitsBehavior parsedUnitsBehavior, final RangeUnitsConverter converter,
99 final Function<ParseToken, List<ParseToken>>[] filters) {
100 super(Tdm.ROOT, Tdm.FORMAT_VERSION_KEY, conventions, simpleEOP, dataContext, parsedUnitsBehavior, filters);
101 this.converter = converter;
102 }
103
104
105 @Override
106 public TdmHeader getHeader() {
107 return header;
108 }
109
110
111 @Override
112 public void reset(final FileFormat fileFormat) {
113 header = new TdmHeader();
114 segments = new ArrayList<>();
115 metadata = null;
116 context = null;
117 observationsBlock = null;
118 if (fileFormat == FileFormat.XML) {
119 structureProcessor = new XmlStructureProcessingState(Tdm.ROOT, this);
120 reset(fileFormat, structureProcessor);
121 } else {
122 structureProcessor = new KvnStructureProcessingState(this);
123 reset(fileFormat, new HeaderProcessingState(this));
124 }
125 }
126
127
128 @Override
129 public Tdm build() {
130 return new Tdm(header, segments, getConventions(), getDataContext());
131 }
132
133
134 @Override
135 public boolean prepareHeader() {
136 anticipateNext(new HeaderProcessingState(this));
137 return true;
138 }
139
140
141 @Override
142 public boolean inHeader() {
143 anticipateNext(structureProcessor);
144 return true;
145 }
146
147
148 @Override
149 public boolean finalizeHeader() {
150 header.validate(header.getFormatVersion());
151 return true;
152 }
153
154
155 @Override
156 public boolean prepareMetadata() {
157 if (metadata != null) {
158 return false;
159 }
160 metadata = new TdmMetadata();
161 context = new ContextBinding(
162 this::getConventions, this::isSimpleEOP,
163 this::getDataContext, this::getParsedUnitsBehavior,
164 () -> null, metadata::getTimeSystem, () -> 0.0, () -> 1.0);
165 anticipateNext(this::processMetadataToken);
166 return true;
167 }
168
169
170 @Override
171 public boolean inMetadata() {
172 anticipateNext(structureProcessor);
173 return true;
174 }
175
176
177 @Override
178 public boolean finalizeMetadata() {
179 metadata.validate(header.getFormatVersion());
180 return true;
181 }
182
183
184 @Override
185 public boolean prepareData() {
186 observationsBlock = new ObservationsBlock();
187 anticipateNext(this::processDataToken);
188 return true;
189 }
190
191
192 @Override
193 public boolean inData() {
194 anticipateNext(structureProcessor);
195 return true;
196 }
197
198
199 @Override
200 public boolean finalizeData() {
201 segments.add(new Segment<>(metadata, observationsBlock));
202 metadata = null;
203 context = null;
204 observationsBlock = null;
205 return true;
206 }
207
208
209
210
211
212 private boolean processMetadataToken(final ParseToken token) {
213 inMetadata();
214 try {
215 return token.getName() != null &&
216 MetadataKey.valueOf(token.getName()).process(token, context, metadata);
217 } catch (IllegalArgumentException iaeM) {
218 try {
219 return TdmMetadataKey.valueOf(token.getName()).process(token, context, metadata);
220 } catch (IllegalArgumentException iaeT) {
221
222 return false;
223 }
224 }
225 }
226
227
228
229
230
231 private boolean processDataToken(final ParseToken token) {
232 try {
233 inData();
234 try {
235
236 return token.getName() != null &&
237 TdmDataKey.valueOf(token.getName()).process(token, context, observationsBlock);
238 } catch (IllegalArgumentException iae) {
239
240 return ObservationType.valueOf(token.getName()).process(token, context, converter, metadata, observationsBlock);
241 }
242 } catch (IllegalArgumentException iae) {
243
244 return false;
245 }
246 }
247
248 }