Line data Source code
1 :
2 : /*
3 : * ALMA - Atacama Large Millimeter Array
4 : * (c) European Southern Observatory, 2002
5 : * (c) Associated Universities Inc., 2002
6 : * Copyright by ESO (in the framework of the ALMA collaboration),
7 : * Copyright by AUI (in the framework of the ALMA collaboration),
8 : * All rights reserved.
9 : *
10 : * This library is free software; you can redistribute it and/or
11 : * modify it under the terms of the GNU Lesser General Public
12 : * License as published by the Free software Foundation; either
13 : * version 2.1 of the License, or (at your option) any later version.
14 : *
15 : * This library is distributed in the hope that it will be useful,
16 : * but WITHOUT ANY WARRANTY, without even the implied warranty of
17 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 : * Lesser General Public License for more details.
19 : *
20 : * You should have received a copy of the GNU Lesser General Public
21 : * License along with this library; if not, write to the Free Software
22 : * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
23 : * MA 02111-1307 USA
24 : *
25 : * Warning!
26 : * --------------------------------------------------------------------
27 : * | This is generated code! Do not modify this file. |
28 : * | If you do, all changes will be lost when the file is re-generated. |
29 : * --------------------------------------------------------------------
30 : *
31 : * File ASDM.cpp
32 : */
33 : #include <alma/ASDM/ASDM.h>
34 :
35 : #include <alma/ASDM/MainTable.h>
36 :
37 : #include <alma/ASDM/AlmaRadiometerTable.h>
38 :
39 : #include <alma/ASDM/AnnotationTable.h>
40 :
41 : #include <alma/ASDM/AntennaTable.h>
42 :
43 : #include <alma/ASDM/CalAmpliTable.h>
44 :
45 : #include <alma/ASDM/CalAntennaSolutionsTable.h>
46 :
47 : #include <alma/ASDM/CalAppPhaseTable.h>
48 :
49 : #include <alma/ASDM/CalAtmosphereTable.h>
50 :
51 : #include <alma/ASDM/CalBandpassTable.h>
52 :
53 : #include <alma/ASDM/CalCurveTable.h>
54 :
55 : #include <alma/ASDM/CalDataTable.h>
56 :
57 : #include <alma/ASDM/CalDelayTable.h>
58 :
59 : #include <alma/ASDM/CalDeviceTable.h>
60 :
61 : #include <alma/ASDM/CalFluxTable.h>
62 :
63 : #include <alma/ASDM/CalFocusTable.h>
64 :
65 : #include <alma/ASDM/CalFocusModelTable.h>
66 :
67 : #include <alma/ASDM/CalGainTable.h>
68 :
69 : #include <alma/ASDM/CalHolographyTable.h>
70 :
71 : #include <alma/ASDM/CalPhaseTable.h>
72 :
73 : #include <alma/ASDM/CalPointingTable.h>
74 :
75 : #include <alma/ASDM/CalPointingModelTable.h>
76 :
77 : #include <alma/ASDM/CalPositionTable.h>
78 :
79 : #include <alma/ASDM/CalPrimaryBeamTable.h>
80 :
81 : #include <alma/ASDM/CalReductionTable.h>
82 :
83 : #include <alma/ASDM/CalSeeingTable.h>
84 :
85 : #include <alma/ASDM/CalWVRTable.h>
86 :
87 : #include <alma/ASDM/ConfigDescriptionTable.h>
88 :
89 : #include <alma/ASDM/CorrelatorModeTable.h>
90 :
91 : #include <alma/ASDM/DataDescriptionTable.h>
92 :
93 : #include <alma/ASDM/DelayModelTable.h>
94 :
95 : #include <alma/ASDM/DelayModelFixedParametersTable.h>
96 :
97 : #include <alma/ASDM/DelayModelVariableParametersTable.h>
98 :
99 : #include <alma/ASDM/DopplerTable.h>
100 :
101 : #include <alma/ASDM/EphemerisTable.h>
102 :
103 : #include <alma/ASDM/ExecBlockTable.h>
104 :
105 : #include <alma/ASDM/FeedTable.h>
106 :
107 : #include <alma/ASDM/FieldTable.h>
108 :
109 : #include <alma/ASDM/FlagTable.h>
110 :
111 : #include <alma/ASDM/FlagCmdTable.h>
112 :
113 : #include <alma/ASDM/FocusTable.h>
114 :
115 : #include <alma/ASDM/FocusModelTable.h>
116 :
117 : #include <alma/ASDM/FreqOffsetTable.h>
118 :
119 : #include <alma/ASDM/GainTrackingTable.h>
120 :
121 : #include <alma/ASDM/HistoryTable.h>
122 :
123 : #include <alma/ASDM/HolographyTable.h>
124 :
125 : #include <alma/ASDM/ObservationTable.h>
126 :
127 : #include <alma/ASDM/PointingTable.h>
128 :
129 : #include <alma/ASDM/PointingModelTable.h>
130 :
131 : #include <alma/ASDM/PolarizationTable.h>
132 :
133 : #include <alma/ASDM/ProcessorTable.h>
134 :
135 : #include <alma/ASDM/PulsarTable.h>
136 :
137 : #include <alma/ASDM/ReceiverTable.h>
138 :
139 : #include <alma/ASDM/SBSummaryTable.h>
140 :
141 : #include <alma/ASDM/ScaleTable.h>
142 :
143 : #include <alma/ASDM/ScanTable.h>
144 :
145 : #include <alma/ASDM/SeeingTable.h>
146 :
147 : #include <alma/ASDM/SourceTable.h>
148 :
149 : #include <alma/ASDM/SpectralWindowTable.h>
150 :
151 : #include <alma/ASDM/SquareLawDetectorTable.h>
152 :
153 : #include <alma/ASDM/StateTable.h>
154 :
155 : #include <alma/ASDM/StationTable.h>
156 :
157 : #include <alma/ASDM/SubscanTable.h>
158 :
159 : #include <alma/ASDM/SwitchCycleTable.h>
160 :
161 : #include <alma/ASDM/SysCalTable.h>
162 :
163 : #include <alma/ASDM/SysPowerTable.h>
164 :
165 : #include <alma/ASDM/TotalPowerTable.h>
166 :
167 : #include <alma/ASDM/VLAWVRTable.h>
168 :
169 : #include <alma/ASDM/WVMCalTable.h>
170 :
171 : #include <alma/ASDM/WeatherTable.h>
172 :
173 :
174 : using asdm::ASDM;
175 :
176 : using asdm::MainTable;
177 :
178 : using asdm::AlmaRadiometerTable;
179 :
180 : using asdm::AnnotationTable;
181 :
182 : using asdm::AntennaTable;
183 :
184 : using asdm::CalAmpliTable;
185 :
186 : using asdm::CalAntennaSolutionsTable;
187 :
188 : using asdm::CalAppPhaseTable;
189 :
190 : using asdm::CalAtmosphereTable;
191 :
192 : using asdm::CalBandpassTable;
193 :
194 : using asdm::CalCurveTable;
195 :
196 : using asdm::CalDataTable;
197 :
198 : using asdm::CalDelayTable;
199 :
200 : using asdm::CalDeviceTable;
201 :
202 : using asdm::CalFluxTable;
203 :
204 : using asdm::CalFocusTable;
205 :
206 : using asdm::CalFocusModelTable;
207 :
208 : using asdm::CalGainTable;
209 :
210 : using asdm::CalHolographyTable;
211 :
212 : using asdm::CalPhaseTable;
213 :
214 : using asdm::CalPointingTable;
215 :
216 : using asdm::CalPointingModelTable;
217 :
218 : using asdm::CalPositionTable;
219 :
220 : using asdm::CalPrimaryBeamTable;
221 :
222 : using asdm::CalReductionTable;
223 :
224 : using asdm::CalSeeingTable;
225 :
226 : using asdm::CalWVRTable;
227 :
228 : using asdm::ConfigDescriptionTable;
229 :
230 : using asdm::CorrelatorModeTable;
231 :
232 : using asdm::DataDescriptionTable;
233 :
234 : using asdm::DelayModelTable;
235 :
236 : using asdm::DelayModelFixedParametersTable;
237 :
238 : using asdm::DelayModelVariableParametersTable;
239 :
240 : using asdm::DopplerTable;
241 :
242 : using asdm::EphemerisTable;
243 :
244 : using asdm::ExecBlockTable;
245 :
246 : using asdm::FeedTable;
247 :
248 : using asdm::FieldTable;
249 :
250 : using asdm::FlagTable;
251 :
252 : using asdm::FlagCmdTable;
253 :
254 : using asdm::FocusTable;
255 :
256 : using asdm::FocusModelTable;
257 :
258 : using asdm::FreqOffsetTable;
259 :
260 : using asdm::GainTrackingTable;
261 :
262 : using asdm::HistoryTable;
263 :
264 : using asdm::HolographyTable;
265 :
266 : using asdm::ObservationTable;
267 :
268 : using asdm::PointingTable;
269 :
270 : using asdm::PointingModelTable;
271 :
272 : using asdm::PolarizationTable;
273 :
274 : using asdm::ProcessorTable;
275 :
276 : using asdm::PulsarTable;
277 :
278 : using asdm::ReceiverTable;
279 :
280 : using asdm::SBSummaryTable;
281 :
282 : using asdm::ScaleTable;
283 :
284 : using asdm::ScanTable;
285 :
286 : using asdm::SeeingTable;
287 :
288 : using asdm::SourceTable;
289 :
290 : using asdm::SpectralWindowTable;
291 :
292 : using asdm::SquareLawDetectorTable;
293 :
294 : using asdm::StateTable;
295 :
296 : using asdm::StationTable;
297 :
298 : using asdm::SubscanTable;
299 :
300 : using asdm::SwitchCycleTable;
301 :
302 : using asdm::SysCalTable;
303 :
304 : using asdm::SysPowerTable;
305 :
306 : using asdm::TotalPowerTable;
307 :
308 : using asdm::VLAWVRTable;
309 :
310 : using asdm::WVMCalTable;
311 :
312 : using asdm::WeatherTable;
313 :
314 :
315 : #include <alma/ASDM/Parser.h>
316 : #include <alma/ASDM/ConversionException.h>
317 :
318 : using asdm::ConversionException;
319 : using asdm::Parser;
320 :
321 : #include <iostream>
322 : #include <fstream>
323 : #include <string>
324 : #include <locale>
325 : #include <time.h>
326 :
327 : //#ifdef WITHOUT_ACS
328 : #include <sys/stat.h>
329 : #include <sys/types.h>
330 : #include <dirent.h>
331 : //#endif
332 :
333 : #include <alma/ASDM/Misc.h>
334 : using namespace asdm;
335 : using namespace std;
336 :
337 : namespace asdm {
338 :
339 0 : ASDM::Origin ASDM::getOrigin() const { return origin ; }
340 :
341 1568 : string ASDM::getDirectory() const { return directory_ ; }
342 :
343 1647 : XSLTransformer & ASDM::getXSLTransformer() { return xslTransformer; }
344 :
345 : /**
346 : * Create an instance of the tables that belong to this model.
347 : */
348 110 : ASDM::ASDM () {
349 110 : Entity emptyEntity;
350 :
351 110 : main = new MainTable (*this);
352 110 : table.push_back(main);
353 110 : tableEntity["Main"] = emptyEntity;
354 :
355 110 : almaRadiometer = new AlmaRadiometerTable (*this);
356 110 : table.push_back(almaRadiometer);
357 110 : tableEntity["AlmaRadiometer"] = emptyEntity;
358 :
359 110 : annotation = new AnnotationTable (*this);
360 110 : table.push_back(annotation);
361 110 : tableEntity["Annotation"] = emptyEntity;
362 :
363 110 : antenna = new AntennaTable (*this);
364 110 : table.push_back(antenna);
365 110 : tableEntity["Antenna"] = emptyEntity;
366 :
367 110 : calAmpli = new CalAmpliTable (*this);
368 110 : table.push_back(calAmpli);
369 110 : tableEntity["CalAmpli"] = emptyEntity;
370 :
371 110 : calAntennaSolutions = new CalAntennaSolutionsTable (*this);
372 110 : table.push_back(calAntennaSolutions);
373 110 : tableEntity["CalAntennaSolutions"] = emptyEntity;
374 :
375 110 : calAppPhase = new CalAppPhaseTable (*this);
376 110 : table.push_back(calAppPhase);
377 110 : tableEntity["CalAppPhase"] = emptyEntity;
378 :
379 110 : calAtmosphere = new CalAtmosphereTable (*this);
380 110 : table.push_back(calAtmosphere);
381 110 : tableEntity["CalAtmosphere"] = emptyEntity;
382 :
383 110 : calBandpass = new CalBandpassTable (*this);
384 110 : table.push_back(calBandpass);
385 110 : tableEntity["CalBandpass"] = emptyEntity;
386 :
387 110 : calCurve = new CalCurveTable (*this);
388 110 : table.push_back(calCurve);
389 110 : tableEntity["CalCurve"] = emptyEntity;
390 :
391 110 : calData = new CalDataTable (*this);
392 110 : table.push_back(calData);
393 110 : tableEntity["CalData"] = emptyEntity;
394 :
395 110 : calDelay = new CalDelayTable (*this);
396 110 : table.push_back(calDelay);
397 110 : tableEntity["CalDelay"] = emptyEntity;
398 :
399 110 : calDevice = new CalDeviceTable (*this);
400 110 : table.push_back(calDevice);
401 110 : tableEntity["CalDevice"] = emptyEntity;
402 :
403 110 : calFlux = new CalFluxTable (*this);
404 110 : table.push_back(calFlux);
405 110 : tableEntity["CalFlux"] = emptyEntity;
406 :
407 110 : calFocus = new CalFocusTable (*this);
408 110 : table.push_back(calFocus);
409 110 : tableEntity["CalFocus"] = emptyEntity;
410 :
411 110 : calFocusModel = new CalFocusModelTable (*this);
412 110 : table.push_back(calFocusModel);
413 110 : tableEntity["CalFocusModel"] = emptyEntity;
414 :
415 110 : calGain = new CalGainTable (*this);
416 110 : table.push_back(calGain);
417 110 : tableEntity["CalGain"] = emptyEntity;
418 :
419 110 : calHolography = new CalHolographyTable (*this);
420 110 : table.push_back(calHolography);
421 110 : tableEntity["CalHolography"] = emptyEntity;
422 :
423 110 : calPhase = new CalPhaseTable (*this);
424 110 : table.push_back(calPhase);
425 110 : tableEntity["CalPhase"] = emptyEntity;
426 :
427 110 : calPointing = new CalPointingTable (*this);
428 110 : table.push_back(calPointing);
429 110 : tableEntity["CalPointing"] = emptyEntity;
430 :
431 110 : calPointingModel = new CalPointingModelTable (*this);
432 110 : table.push_back(calPointingModel);
433 110 : tableEntity["CalPointingModel"] = emptyEntity;
434 :
435 110 : calPosition = new CalPositionTable (*this);
436 110 : table.push_back(calPosition);
437 110 : tableEntity["CalPosition"] = emptyEntity;
438 :
439 110 : calPrimaryBeam = new CalPrimaryBeamTable (*this);
440 110 : table.push_back(calPrimaryBeam);
441 110 : tableEntity["CalPrimaryBeam"] = emptyEntity;
442 :
443 110 : calReduction = new CalReductionTable (*this);
444 110 : table.push_back(calReduction);
445 110 : tableEntity["CalReduction"] = emptyEntity;
446 :
447 110 : calSeeing = new CalSeeingTable (*this);
448 110 : table.push_back(calSeeing);
449 110 : tableEntity["CalSeeing"] = emptyEntity;
450 :
451 110 : calWVR = new CalWVRTable (*this);
452 110 : table.push_back(calWVR);
453 110 : tableEntity["CalWVR"] = emptyEntity;
454 :
455 110 : configDescription = new ConfigDescriptionTable (*this);
456 110 : table.push_back(configDescription);
457 110 : tableEntity["ConfigDescription"] = emptyEntity;
458 :
459 110 : correlatorMode = new CorrelatorModeTable (*this);
460 110 : table.push_back(correlatorMode);
461 110 : tableEntity["CorrelatorMode"] = emptyEntity;
462 :
463 110 : dataDescription = new DataDescriptionTable (*this);
464 110 : table.push_back(dataDescription);
465 110 : tableEntity["DataDescription"] = emptyEntity;
466 :
467 110 : delayModel = new DelayModelTable (*this);
468 110 : table.push_back(delayModel);
469 110 : tableEntity["DelayModel"] = emptyEntity;
470 :
471 110 : delayModelFixedParameters = new DelayModelFixedParametersTable (*this);
472 110 : table.push_back(delayModelFixedParameters);
473 110 : tableEntity["DelayModelFixedParameters"] = emptyEntity;
474 :
475 110 : delayModelVariableParameters = new DelayModelVariableParametersTable (*this);
476 110 : table.push_back(delayModelVariableParameters);
477 110 : tableEntity["DelayModelVariableParameters"] = emptyEntity;
478 :
479 110 : doppler = new DopplerTable (*this);
480 110 : table.push_back(doppler);
481 110 : tableEntity["Doppler"] = emptyEntity;
482 :
483 110 : ephemeris = new EphemerisTable (*this);
484 110 : table.push_back(ephemeris);
485 110 : tableEntity["Ephemeris"] = emptyEntity;
486 :
487 110 : execBlock = new ExecBlockTable (*this);
488 110 : table.push_back(execBlock);
489 110 : tableEntity["ExecBlock"] = emptyEntity;
490 :
491 110 : feed = new FeedTable (*this);
492 110 : table.push_back(feed);
493 110 : tableEntity["Feed"] = emptyEntity;
494 :
495 110 : field = new FieldTable (*this);
496 110 : table.push_back(field);
497 110 : tableEntity["Field"] = emptyEntity;
498 :
499 110 : flag = new FlagTable (*this);
500 110 : table.push_back(flag);
501 110 : tableEntity["Flag"] = emptyEntity;
502 :
503 110 : flagCmd = new FlagCmdTable (*this);
504 110 : table.push_back(flagCmd);
505 110 : tableEntity["FlagCmd"] = emptyEntity;
506 :
507 110 : focus = new FocusTable (*this);
508 110 : table.push_back(focus);
509 110 : tableEntity["Focus"] = emptyEntity;
510 :
511 110 : focusModel = new FocusModelTable (*this);
512 110 : table.push_back(focusModel);
513 110 : tableEntity["FocusModel"] = emptyEntity;
514 :
515 110 : freqOffset = new FreqOffsetTable (*this);
516 110 : table.push_back(freqOffset);
517 110 : tableEntity["FreqOffset"] = emptyEntity;
518 :
519 110 : gainTracking = new GainTrackingTable (*this);
520 110 : table.push_back(gainTracking);
521 110 : tableEntity["GainTracking"] = emptyEntity;
522 :
523 110 : history = new HistoryTable (*this);
524 110 : table.push_back(history);
525 110 : tableEntity["History"] = emptyEntity;
526 :
527 110 : holography = new HolographyTable (*this);
528 110 : table.push_back(holography);
529 110 : tableEntity["Holography"] = emptyEntity;
530 :
531 110 : observation = new ObservationTable (*this);
532 110 : table.push_back(observation);
533 110 : tableEntity["Observation"] = emptyEntity;
534 :
535 110 : pointing = new PointingTable (*this);
536 110 : table.push_back(pointing);
537 110 : tableEntity["Pointing"] = emptyEntity;
538 :
539 110 : pointingModel = new PointingModelTable (*this);
540 110 : table.push_back(pointingModel);
541 110 : tableEntity["PointingModel"] = emptyEntity;
542 :
543 110 : polarization = new PolarizationTable (*this);
544 110 : table.push_back(polarization);
545 110 : tableEntity["Polarization"] = emptyEntity;
546 :
547 110 : processor = new ProcessorTable (*this);
548 110 : table.push_back(processor);
549 110 : tableEntity["Processor"] = emptyEntity;
550 :
551 110 : pulsar = new PulsarTable (*this);
552 110 : table.push_back(pulsar);
553 110 : tableEntity["Pulsar"] = emptyEntity;
554 :
555 110 : receiver = new ReceiverTable (*this);
556 110 : table.push_back(receiver);
557 110 : tableEntity["Receiver"] = emptyEntity;
558 :
559 110 : sBSummary = new SBSummaryTable (*this);
560 110 : table.push_back(sBSummary);
561 110 : tableEntity["SBSummary"] = emptyEntity;
562 :
563 110 : scale = new ScaleTable (*this);
564 110 : table.push_back(scale);
565 110 : tableEntity["Scale"] = emptyEntity;
566 :
567 110 : scan = new ScanTable (*this);
568 110 : table.push_back(scan);
569 110 : tableEntity["Scan"] = emptyEntity;
570 :
571 110 : seeing = new SeeingTable (*this);
572 110 : table.push_back(seeing);
573 110 : tableEntity["Seeing"] = emptyEntity;
574 :
575 110 : source = new SourceTable (*this);
576 110 : table.push_back(source);
577 110 : tableEntity["Source"] = emptyEntity;
578 :
579 110 : spectralWindow = new SpectralWindowTable (*this);
580 110 : table.push_back(spectralWindow);
581 110 : tableEntity["SpectralWindow"] = emptyEntity;
582 :
583 110 : squareLawDetector = new SquareLawDetectorTable (*this);
584 110 : table.push_back(squareLawDetector);
585 110 : tableEntity["SquareLawDetector"] = emptyEntity;
586 :
587 110 : state = new StateTable (*this);
588 110 : table.push_back(state);
589 110 : tableEntity["State"] = emptyEntity;
590 :
591 110 : station = new StationTable (*this);
592 110 : table.push_back(station);
593 110 : tableEntity["Station"] = emptyEntity;
594 :
595 110 : subscan = new SubscanTable (*this);
596 110 : table.push_back(subscan);
597 110 : tableEntity["Subscan"] = emptyEntity;
598 :
599 110 : switchCycle = new SwitchCycleTable (*this);
600 110 : table.push_back(switchCycle);
601 110 : tableEntity["SwitchCycle"] = emptyEntity;
602 :
603 110 : sysCal = new SysCalTable (*this);
604 110 : table.push_back(sysCal);
605 110 : tableEntity["SysCal"] = emptyEntity;
606 :
607 110 : sysPower = new SysPowerTable (*this);
608 110 : table.push_back(sysPower);
609 110 : tableEntity["SysPower"] = emptyEntity;
610 :
611 110 : totalPower = new TotalPowerTable (*this);
612 110 : table.push_back(totalPower);
613 110 : tableEntity["TotalPower"] = emptyEntity;
614 :
615 110 : vLAWVR = new VLAWVRTable (*this);
616 110 : table.push_back(vLAWVR);
617 110 : tableEntity["VLAWVR"] = emptyEntity;
618 :
619 110 : wVMCal = new WVMCalTable (*this);
620 110 : table.push_back(wVMCal);
621 110 : tableEntity["WVMCal"] = emptyEntity;
622 :
623 110 : weather = new WeatherTable (*this);
624 110 : table.push_back(weather);
625 110 : tableEntity["Weather"] = emptyEntity;
626 :
627 : //for (unsigned int i = 0; i < table.size(); ++i)
628 : // tableEntity.push_back(new Entity ());
629 :
630 : // Define a default entity.
631 110 : entity.setEntityId(EntityId("uid://X0/X0/X0"));
632 110 : entity.setEntityIdEncrypted("na");
633 110 : entity.setEntityTypeName("ASDM");
634 110 : entity.setEntityVersion("1");
635 110 : entity.setInstanceVersion("1");
636 :
637 :
638 : // Define a default creation time : now.
639 : time_t rawtime;
640 110 : time(&rawtime);
641 110 : struct tm* timeInfo = localtime(&rawtime);
642 : //setTimeOfCreation(ArrayTime((1900+timeInfo->tm_year), (timeInfo->tm_mon+1), timeInfo->tm_mday, timeInfo->tm_hour, timeInfo->tm_min, (double) timeInfo->tm_sec));
643 110 : timeOfCreation = ArrayTime((1900+timeInfo->tm_year), (timeInfo->tm_mon+1), timeInfo->tm_mday, timeInfo->tm_hour, timeInfo->tm_min, (double) timeInfo->tm_sec);
644 : // Archive binary or XML
645 110 : archiveAsBin = false;
646 :
647 : // File binary or XML
648 110 : fileAsBin = false;
649 :
650 : // Set imperatively to false
651 110 : hasBeenAdded = false;
652 :
653 : // So far it's created ex nihilo.
654 110 : origin = EX_NIHILO;
655 110 : loadTablesOnDemand_ = false;
656 110 : checkRowUniqueness_ = true;
657 110 : }
658 :
659 196 : ASDM::~ASDM () {
660 7700 : for (unsigned int i = 0; i < table.size(); ++i) {
661 7590 : delete table[i];
662 : //delete tableEntity[i];
663 : }
664 196 : }
665 :
666 :
667 : /**
668 : * Get the table Main.
669 : * @return The table Main as a MainTable.
670 : */
671 627 : MainTable & ASDM::getMain () const {
672 627 : return *main;
673 : }
674 :
675 : /**
676 : * Get the table AlmaRadiometer.
677 : * @return The table AlmaRadiometer as a AlmaRadiometerTable.
678 : */
679 96 : AlmaRadiometerTable & ASDM::getAlmaRadiometer () const {
680 96 : return *almaRadiometer;
681 : }
682 :
683 : /**
684 : * Get the table Annotation.
685 : * @return The table Annotation as a AnnotationTable.
686 : */
687 96 : AnnotationTable & ASDM::getAnnotation () const {
688 96 : return *annotation;
689 : }
690 :
691 : /**
692 : * Get the table Antenna.
693 : * @return The table Antenna as a AntennaTable.
694 : */
695 315 : AntennaTable & ASDM::getAntenna () const {
696 315 : return *antenna;
697 : }
698 :
699 : /**
700 : * Get the table CalAmpli.
701 : * @return The table CalAmpli as a CalAmpliTable.
702 : */
703 96 : CalAmpliTable & ASDM::getCalAmpli () const {
704 96 : return *calAmpli;
705 : }
706 :
707 : /**
708 : * Get the table CalAntennaSolutions.
709 : * @return The table CalAntennaSolutions as a CalAntennaSolutionsTable.
710 : */
711 96 : CalAntennaSolutionsTable & ASDM::getCalAntennaSolutions () const {
712 96 : return *calAntennaSolutions;
713 : }
714 :
715 : /**
716 : * Get the table CalAppPhase.
717 : * @return The table CalAppPhase as a CalAppPhaseTable.
718 : */
719 96 : CalAppPhaseTable & ASDM::getCalAppPhase () const {
720 96 : return *calAppPhase;
721 : }
722 :
723 : /**
724 : * Get the table CalAtmosphere.
725 : * @return The table CalAtmosphere as a CalAtmosphereTable.
726 : */
727 96 : CalAtmosphereTable & ASDM::getCalAtmosphere () const {
728 96 : return *calAtmosphere;
729 : }
730 :
731 : /**
732 : * Get the table CalBandpass.
733 : * @return The table CalBandpass as a CalBandpassTable.
734 : */
735 96 : CalBandpassTable & ASDM::getCalBandpass () const {
736 96 : return *calBandpass;
737 : }
738 :
739 : /**
740 : * Get the table CalCurve.
741 : * @return The table CalCurve as a CalCurveTable.
742 : */
743 96 : CalCurveTable & ASDM::getCalCurve () const {
744 96 : return *calCurve;
745 : }
746 :
747 : /**
748 : * Get the table CalData.
749 : * @return The table CalData as a CalDataTable.
750 : */
751 96 : CalDataTable & ASDM::getCalData () const {
752 96 : return *calData;
753 : }
754 :
755 : /**
756 : * Get the table CalDelay.
757 : * @return The table CalDelay as a CalDelayTable.
758 : */
759 96 : CalDelayTable & ASDM::getCalDelay () const {
760 96 : return *calDelay;
761 : }
762 :
763 : /**
764 : * Get the table CalDevice.
765 : * @return The table CalDevice as a CalDeviceTable.
766 : */
767 168 : CalDeviceTable & ASDM::getCalDevice () const {
768 168 : return *calDevice;
769 : }
770 :
771 : /**
772 : * Get the table CalFlux.
773 : * @return The table CalFlux as a CalFluxTable.
774 : */
775 96 : CalFluxTable & ASDM::getCalFlux () const {
776 96 : return *calFlux;
777 : }
778 :
779 : /**
780 : * Get the table CalFocus.
781 : * @return The table CalFocus as a CalFocusTable.
782 : */
783 96 : CalFocusTable & ASDM::getCalFocus () const {
784 96 : return *calFocus;
785 : }
786 :
787 : /**
788 : * Get the table CalFocusModel.
789 : * @return The table CalFocusModel as a CalFocusModelTable.
790 : */
791 96 : CalFocusModelTable & ASDM::getCalFocusModel () const {
792 96 : return *calFocusModel;
793 : }
794 :
795 : /**
796 : * Get the table CalGain.
797 : * @return The table CalGain as a CalGainTable.
798 : */
799 96 : CalGainTable & ASDM::getCalGain () const {
800 96 : return *calGain;
801 : }
802 :
803 : /**
804 : * Get the table CalHolography.
805 : * @return The table CalHolography as a CalHolographyTable.
806 : */
807 96 : CalHolographyTable & ASDM::getCalHolography () const {
808 96 : return *calHolography;
809 : }
810 :
811 : /**
812 : * Get the table CalPhase.
813 : * @return The table CalPhase as a CalPhaseTable.
814 : */
815 96 : CalPhaseTable & ASDM::getCalPhase () const {
816 96 : return *calPhase;
817 : }
818 :
819 : /**
820 : * Get the table CalPointing.
821 : * @return The table CalPointing as a CalPointingTable.
822 : */
823 96 : CalPointingTable & ASDM::getCalPointing () const {
824 96 : return *calPointing;
825 : }
826 :
827 : /**
828 : * Get the table CalPointingModel.
829 : * @return The table CalPointingModel as a CalPointingModelTable.
830 : */
831 96 : CalPointingModelTable & ASDM::getCalPointingModel () const {
832 96 : return *calPointingModel;
833 : }
834 :
835 : /**
836 : * Get the table CalPosition.
837 : * @return The table CalPosition as a CalPositionTable.
838 : */
839 96 : CalPositionTable & ASDM::getCalPosition () const {
840 96 : return *calPosition;
841 : }
842 :
843 : /**
844 : * Get the table CalPrimaryBeam.
845 : * @return The table CalPrimaryBeam as a CalPrimaryBeamTable.
846 : */
847 96 : CalPrimaryBeamTable & ASDM::getCalPrimaryBeam () const {
848 96 : return *calPrimaryBeam;
849 : }
850 :
851 : /**
852 : * Get the table CalReduction.
853 : * @return The table CalReduction as a CalReductionTable.
854 : */
855 96 : CalReductionTable & ASDM::getCalReduction () const {
856 96 : return *calReduction;
857 : }
858 :
859 : /**
860 : * Get the table CalSeeing.
861 : * @return The table CalSeeing as a CalSeeingTable.
862 : */
863 96 : CalSeeingTable & ASDM::getCalSeeing () const {
864 96 : return *calSeeing;
865 : }
866 :
867 : /**
868 : * Get the table CalWVR.
869 : * @return The table CalWVR as a CalWVRTable.
870 : */
871 96 : CalWVRTable & ASDM::getCalWVR () const {
872 96 : return *calWVR;
873 : }
874 :
875 : /**
876 : * Get the table ConfigDescription.
877 : * @return The table ConfigDescription as a ConfigDescriptionTable.
878 : */
879 6941762 : ConfigDescriptionTable & ASDM::getConfigDescription () const {
880 6941762 : return *configDescription;
881 : }
882 :
883 : /**
884 : * Get the table CorrelatorMode.
885 : * @return The table CorrelatorMode as a CorrelatorModeTable.
886 : */
887 209 : CorrelatorModeTable & ASDM::getCorrelatorMode () const {
888 209 : return *correlatorMode;
889 : }
890 :
891 : /**
892 : * Get the table DataDescription.
893 : * @return The table DataDescription as a DataDescriptionTable.
894 : */
895 8114 : DataDescriptionTable & ASDM::getDataDescription () const {
896 8114 : return *dataDescription;
897 : }
898 :
899 : /**
900 : * Get the table DelayModel.
901 : * @return The table DelayModel as a DelayModelTable.
902 : */
903 96 : DelayModelTable & ASDM::getDelayModel () const {
904 96 : return *delayModel;
905 : }
906 :
907 : /**
908 : * Get the table DelayModelFixedParameters.
909 : * @return The table DelayModelFixedParameters as a DelayModelFixedParametersTable.
910 : */
911 96 : DelayModelFixedParametersTable & ASDM::getDelayModelFixedParameters () const {
912 96 : return *delayModelFixedParameters;
913 : }
914 :
915 : /**
916 : * Get the table DelayModelVariableParameters.
917 : * @return The table DelayModelVariableParameters as a DelayModelVariableParametersTable.
918 : */
919 96 : DelayModelVariableParametersTable & ASDM::getDelayModelVariableParameters () const {
920 96 : return *delayModelVariableParameters;
921 : }
922 :
923 : /**
924 : * Get the table Doppler.
925 : * @return The table Doppler as a DopplerTable.
926 : */
927 96 : DopplerTable & ASDM::getDoppler () const {
928 96 : return *doppler;
929 : }
930 :
931 : /**
932 : * Get the table Ephemeris.
933 : * @return The table Ephemeris as a EphemerisTable.
934 : */
935 177 : EphemerisTable & ASDM::getEphemeris () const {
936 177 : return *ephemeris;
937 : }
938 :
939 : /**
940 : * Get the table ExecBlock.
941 : * @return The table ExecBlock as a ExecBlockTable.
942 : */
943 6227 : ExecBlockTable & ASDM::getExecBlock () const {
944 6227 : return *execBlock;
945 : }
946 :
947 : /**
948 : * Get the table Feed.
949 : * @return The table Feed as a FeedTable.
950 : */
951 208 : FeedTable & ASDM::getFeed () const {
952 208 : return *feed;
953 : }
954 :
955 : /**
956 : * Get the table Field.
957 : * @return The table Field as a FieldTable.
958 : */
959 11309 : FieldTable & ASDM::getField () const {
960 11309 : return *field;
961 : }
962 :
963 : /**
964 : * Get the table Flag.
965 : * @return The table Flag as a FlagTable.
966 : */
967 96 : FlagTable & ASDM::getFlag () const {
968 96 : return *flag;
969 : }
970 :
971 : /**
972 : * Get the table FlagCmd.
973 : * @return The table FlagCmd as a FlagCmdTable.
974 : */
975 168 : FlagCmdTable & ASDM::getFlagCmd () const {
976 168 : return *flagCmd;
977 : }
978 :
979 : /**
980 : * Get the table Focus.
981 : * @return The table Focus as a FocusTable.
982 : */
983 96 : FocusTable & ASDM::getFocus () const {
984 96 : return *focus;
985 : }
986 :
987 : /**
988 : * Get the table FocusModel.
989 : * @return The table FocusModel as a FocusModelTable.
990 : */
991 96 : FocusModelTable & ASDM::getFocusModel () const {
992 96 : return *focusModel;
993 : }
994 :
995 : /**
996 : * Get the table FreqOffset.
997 : * @return The table FreqOffset as a FreqOffsetTable.
998 : */
999 96 : FreqOffsetTable & ASDM::getFreqOffset () const {
1000 96 : return *freqOffset;
1001 : }
1002 :
1003 : /**
1004 : * Get the table GainTracking.
1005 : * @return The table GainTracking as a GainTrackingTable.
1006 : */
1007 96 : GainTrackingTable & ASDM::getGainTracking () const {
1008 96 : return *gainTracking;
1009 : }
1010 :
1011 : /**
1012 : * Get the table History.
1013 : * @return The table History as a HistoryTable.
1014 : */
1015 168 : HistoryTable & ASDM::getHistory () const {
1016 168 : return *history;
1017 : }
1018 :
1019 : /**
1020 : * Get the table Holography.
1021 : * @return The table Holography as a HolographyTable.
1022 : */
1023 96 : HolographyTable & ASDM::getHolography () const {
1024 96 : return *holography;
1025 : }
1026 :
1027 : /**
1028 : * Get the table Observation.
1029 : * @return The table Observation as a ObservationTable.
1030 : */
1031 96 : ObservationTable & ASDM::getObservation () const {
1032 96 : return *observation;
1033 : }
1034 :
1035 : /**
1036 : * Get the table Pointing.
1037 : * @return The table Pointing as a PointingTable.
1038 : */
1039 176 : PointingTable & ASDM::getPointing () const {
1040 176 : return *pointing;
1041 : }
1042 :
1043 : /**
1044 : * Get the table PointingModel.
1045 : * @return The table PointingModel as a PointingModelTable.
1046 : */
1047 122 : PointingModelTable & ASDM::getPointingModel () const {
1048 122 : return *pointingModel;
1049 : }
1050 :
1051 : /**
1052 : * Get the table Polarization.
1053 : * @return The table Polarization as a PolarizationTable.
1054 : */
1055 8858 : PolarizationTable & ASDM::getPolarization () const {
1056 8858 : return *polarization;
1057 : }
1058 :
1059 : /**
1060 : * Get the table Processor.
1061 : * @return The table Processor as a ProcessorTable.
1062 : */
1063 6926095 : ProcessorTable & ASDM::getProcessor () const {
1064 6926095 : return *processor;
1065 : }
1066 :
1067 : /**
1068 : * Get the table Pulsar.
1069 : * @return The table Pulsar as a PulsarTable.
1070 : */
1071 96 : PulsarTable & ASDM::getPulsar () const {
1072 96 : return *pulsar;
1073 : }
1074 :
1075 : /**
1076 : * Get the table Receiver.
1077 : * @return The table Receiver as a ReceiverTable.
1078 : */
1079 1915 : ReceiverTable & ASDM::getReceiver () const {
1080 1915 : return *receiver;
1081 : }
1082 :
1083 : /**
1084 : * Get the table SBSummary.
1085 : * @return The table SBSummary as a SBSummaryTable.
1086 : */
1087 265 : SBSummaryTable & ASDM::getSBSummary () const {
1088 265 : return *sBSummary;
1089 : }
1090 :
1091 : /**
1092 : * Get the table Scale.
1093 : * @return The table Scale as a ScaleTable.
1094 : */
1095 96 : ScaleTable & ASDM::getScale () const {
1096 96 : return *scale;
1097 : }
1098 :
1099 : /**
1100 : * Get the table Scan.
1101 : * @return The table Scan as a ScanTable.
1102 : */
1103 8305 : ScanTable & ASDM::getScan () const {
1104 8305 : return *scan;
1105 : }
1106 :
1107 : /**
1108 : * Get the table Seeing.
1109 : * @return The table Seeing as a SeeingTable.
1110 : */
1111 96 : SeeingTable & ASDM::getSeeing () const {
1112 96 : return *seeing;
1113 : }
1114 :
1115 : /**
1116 : * Get the table Source.
1117 : * @return The table Source as a SourceTable.
1118 : */
1119 195 : SourceTable & ASDM::getSource () const {
1120 195 : return *source;
1121 : }
1122 :
1123 : /**
1124 : * Get the table SpectralWindow.
1125 : * @return The table SpectralWindow as a SpectralWindowTable.
1126 : */
1127 1574 : SpectralWindowTable & ASDM::getSpectralWindow () const {
1128 1574 : return *spectralWindow;
1129 : }
1130 :
1131 : /**
1132 : * Get the table SquareLawDetector.
1133 : * @return The table SquareLawDetector as a SquareLawDetectorTable.
1134 : */
1135 96 : SquareLawDetectorTable & ASDM::getSquareLawDetector () const {
1136 96 : return *squareLawDetector;
1137 : }
1138 :
1139 : /**
1140 : * Get the table State.
1141 : * @return The table State as a StateTable.
1142 : */
1143 11226 : StateTable & ASDM::getState () const {
1144 11226 : return *state;
1145 : }
1146 :
1147 : /**
1148 : * Get the table Station.
1149 : * @return The table Station as a StationTable.
1150 : */
1151 8626 : StationTable & ASDM::getStation () const {
1152 8626 : return *station;
1153 : }
1154 :
1155 : /**
1156 : * Get the table Subscan.
1157 : * @return The table Subscan as a SubscanTable.
1158 : */
1159 3613 : SubscanTable & ASDM::getSubscan () const {
1160 3613 : return *subscan;
1161 : }
1162 :
1163 : /**
1164 : * Get the table SwitchCycle.
1165 : * @return The table SwitchCycle as a SwitchCycleTable.
1166 : */
1167 1368 : SwitchCycleTable & ASDM::getSwitchCycle () const {
1168 1368 : return *switchCycle;
1169 : }
1170 :
1171 : /**
1172 : * Get the table SysCal.
1173 : * @return The table SysCal as a SysCalTable.
1174 : */
1175 892 : SysCalTable & ASDM::getSysCal () const {
1176 892 : return *sysCal;
1177 : }
1178 :
1179 : /**
1180 : * Get the table SysPower.
1181 : * @return The table SysPower as a SysPowerTable.
1182 : */
1183 155 : SysPowerTable & ASDM::getSysPower () const {
1184 155 : return *sysPower;
1185 : }
1186 :
1187 : /**
1188 : * Get the table TotalPower.
1189 : * @return The table TotalPower as a TotalPowerTable.
1190 : */
1191 96 : TotalPowerTable & ASDM::getTotalPower () const {
1192 96 : return *totalPower;
1193 : }
1194 :
1195 : /**
1196 : * Get the table VLAWVR.
1197 : * @return The table VLAWVR as a VLAWVRTable.
1198 : */
1199 96 : VLAWVRTable & ASDM::getVLAWVR () const {
1200 96 : return *vLAWVR;
1201 : }
1202 :
1203 : /**
1204 : * Get the table WVMCal.
1205 : * @return The table WVMCal as a WVMCalTable.
1206 : */
1207 96 : WVMCalTable & ASDM::getWVMCal () const {
1208 96 : return *wVMCal;
1209 : }
1210 :
1211 : /**
1212 : * Get the table Weather.
1213 : * @return The table Weather as a WeatherTable.
1214 : */
1215 168 : WeatherTable & ASDM::getWeather () const {
1216 168 : return *weather;
1217 : }
1218 :
1219 :
1220 :
1221 13 : string ASDM::toXML() const {
1222 13 : string out;
1223 13 : out.append("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?> ");
1224 13 : out.append("<ASDM xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:cntnr=\"http://Alma/XASDM/ASDM\" xsi:schemaLocation=\"http://Alma/XASDM/ASDM http://almaobservatory.org/XML/XASDM/4/ASDM.xsd\" schemaVersion=\"4\" schemaRevision=\"-1\"> ");
1225 :
1226 13 : if (entity.isNull())
1227 0 : throw ConversionException("Container entity cannot be null.","Container");
1228 13 : out.append(entity.toXML());
1229 13 : out.append(" ");
1230 13 : out.append("<TimeOfCreation> ");
1231 13 : out.append(timeOfCreation.toFITS());
1232 13 : out.append(" ");
1233 13 : out.append("</TimeOfCreation>");
1234 910 : for (unsigned int i = 0; i < table.size(); ++i) {
1235 897 : out.append("<Table> ");
1236 897 : out.append("<Name> ");
1237 897 : out.append(table[i]->getName());
1238 897 : out.append(" ");
1239 897 : out.append("</Name> ");
1240 897 : out.append("<NumberRows> ");
1241 897 : out.append(Integer::toString(table[i]->size()));
1242 897 : out.append(" ");
1243 897 : out.append("</NumberRows> ");
1244 897 : if (table[i]->size() > 0) {
1245 282 : if (table[i]->getEntity().isNull())
1246 0 : throw ConversionException("Table entity is null.",table[i]->getName());
1247 282 : out.append(table[i]->getEntity().toXML());
1248 : }
1249 897 : out.append(" ");
1250 897 : out.append("</Table> ");
1251 : }
1252 13 : out.append("</ASDM>");
1253 13 : return out;
1254 : }
1255 :
1256 :
1257 :
1258 83 : void ASDM::fromXML(string xmlDoc) {
1259 166 : Parser xml(xmlDoc);
1260 83 : if (!xml.isStr("<ASDM"))
1261 0 : error();
1262 249 : string s = xml.getElement("<Entity","/>");
1263 83 : if (s.length() == 0)
1264 0 : error();
1265 166 : Entity e;
1266 83 : e.setFromXML(s);
1267 83 : if (e.getEntityTypeName() != "ASDM")
1268 0 : error();
1269 83 : setEntity(e);
1270 :
1271 83 : s = xml.getElementContent("<TimeOfCreation>","</TimeOfCreation>");
1272 83 : if (s.length() == 0)
1273 0 : error();
1274 166 : ArrayTime t(s);
1275 : //setTimeOfCreation(t);
1276 83 : timeOfCreation = t;
1277 :
1278 : // Do we have an element startTimeDurationInXML
1279 83 : s = xml.getElement("<startTimeDurationInXML","/>");
1280 83 : if (s.length() != 0)
1281 5 : ArrayTimeInterval::readStartTimeDurationInXML(true);
1282 : else
1283 78 : ArrayTimeInterval::readStartTimeDurationInXML(false);
1284 :
1285 : // Do we have an element startTimeDurationInBin
1286 83 : s = xml.getElement("<startTimeDurationInBin","/>");
1287 83 : if (s.length() != 0)
1288 5 : ArrayTimeInterval::readStartTimeDurationInBin(true);
1289 : else
1290 78 : ArrayTimeInterval::readStartTimeDurationInBin(false);
1291 :
1292 : // Get each table in the dataset.
1293 83 : s = xml.getElementContent("<Table>","</Table>");
1294 4548 : while (s.length() != 0) {
1295 8930 : Parser tab(s);
1296 4465 : s = tab.getElementContent("<Name>","</Name>");
1297 4465 : if (s.length() == 0)
1298 0 : error();
1299 4465 : string tableName = s;
1300 4465 : s = tab.getElementContent("<NumberRows>","</NumberRows>");
1301 4465 : if (s.length() == 0)
1302 0 : error();
1303 4465 : int numberRows = 0;
1304 : try {
1305 4465 : numberRows = Integer::parseInt(s);
1306 4470 : getTable(tableName).declaredSize = numberRows;
1307 4460 : if (numberRows > 0 ) {
1308 2558 : s = tab.getElementContent("<Entity","/>");
1309 2558 : if (s.length() == 0)
1310 0 : error();
1311 5116 : Entity tabE;
1312 2558 : tabE.setFromXML(s);
1313 2558 : if (tabE.getEntityTypeName() != (tableName + "Table"))
1314 0 : error();
1315 2558 : tableEntity[tableName] = tabE;
1316 : }
1317 : }
1318 0 : catch (const NumberFormatException &err) {
1319 0 : error(); // Expected to happen while parsing the number of rows.
1320 : }
1321 5 : catch (const InvalidArgumentException &err) {
1322 : ; // This happens when the name of a table which is not recognized by this
1323 : // version of the software. Then we simply ignore it !
1324 : }
1325 4465 : s = xml.getElementContent("<Table>","</Table>");
1326 : }
1327 83 : if (!xml.isStr("</ASDM>"))
1328 0 : error();
1329 83 : }
1330 :
1331 :
1332 : #ifndef WITHOUT_ACS
1333 : using namespace asdmIDL;
1334 : #endif
1335 :
1336 : #ifndef WITHOUT_ACS
1337 : ASDMDataSetIDL* ASDM::toIDL() {
1338 : ASDMDataSetIDL* result = new ASDMDataSetIDL();
1339 :
1340 : result->main = *(this->main->toIDL());
1341 :
1342 : result->almaRadiometer = *(this->almaRadiometer->toIDL());
1343 :
1344 : result->annotation = *(this->annotation->toIDL());
1345 :
1346 : result->antenna = *(this->antenna->toIDL());
1347 :
1348 : result->calAmpli = *(this->calAmpli->toIDL());
1349 :
1350 : result->calAntennaSolutions = *(this->calAntennaSolutions->toIDL());
1351 :
1352 : result->calAppPhase = *(this->calAppPhase->toIDL());
1353 :
1354 : result->calAtmosphere = *(this->calAtmosphere->toIDL());
1355 :
1356 : result->calBandpass = *(this->calBandpass->toIDL());
1357 :
1358 : result->calCurve = *(this->calCurve->toIDL());
1359 :
1360 : result->calData = *(this->calData->toIDL());
1361 :
1362 : result->calDelay = *(this->calDelay->toIDL());
1363 :
1364 : result->calDevice = *(this->calDevice->toIDL());
1365 :
1366 : result->calFlux = *(this->calFlux->toIDL());
1367 :
1368 : result->calFocus = *(this->calFocus->toIDL());
1369 :
1370 : result->calFocusModel = *(this->calFocusModel->toIDL());
1371 :
1372 : result->calGain = *(this->calGain->toIDL());
1373 :
1374 : result->calHolography = *(this->calHolography->toIDL());
1375 :
1376 : result->calPhase = *(this->calPhase->toIDL());
1377 :
1378 : result->calPointing = *(this->calPointing->toIDL());
1379 :
1380 : result->calPointingModel = *(this->calPointingModel->toIDL());
1381 :
1382 : result->calPosition = *(this->calPosition->toIDL());
1383 :
1384 : result->calPrimaryBeam = *(this->calPrimaryBeam->toIDL());
1385 :
1386 : result->calReduction = *(this->calReduction->toIDL());
1387 :
1388 : result->calSeeing = *(this->calSeeing->toIDL());
1389 :
1390 : result->calWVR = *(this->calWVR->toIDL());
1391 :
1392 : result->configDescription = *(this->configDescription->toIDL());
1393 :
1394 : result->correlatorMode = *(this->correlatorMode->toIDL());
1395 :
1396 : result->dataDescription = *(this->dataDescription->toIDL());
1397 :
1398 : result->delayModel = *(this->delayModel->toIDL());
1399 :
1400 : result->delayModelFixedParameters = *(this->delayModelFixedParameters->toIDL());
1401 :
1402 : result->delayModelVariableParameters = *(this->delayModelVariableParameters->toIDL());
1403 :
1404 : result->doppler = *(this->doppler->toIDL());
1405 :
1406 : result->ephemeris = *(this->ephemeris->toIDL());
1407 :
1408 : result->execBlock = *(this->execBlock->toIDL());
1409 :
1410 : result->feed = *(this->feed->toIDL());
1411 :
1412 : result->field = *(this->field->toIDL());
1413 :
1414 : result->flag = *(this->flag->toIDL());
1415 :
1416 : result->flagCmd = *(this->flagCmd->toIDL());
1417 :
1418 : result->focus = *(this->focus->toIDL());
1419 :
1420 : result->focusModel = *(this->focusModel->toIDL());
1421 :
1422 : result->freqOffset = *(this->freqOffset->toIDL());
1423 :
1424 : result->gainTracking = *(this->gainTracking->toIDL());
1425 :
1426 : result->history = *(this->history->toIDL());
1427 :
1428 : result->holography = *(this->holography->toIDL());
1429 :
1430 : result->observation = *(this->observation->toIDL());
1431 :
1432 : result->pointing = *(this->pointing->toIDL());
1433 :
1434 : result->pointingModel = *(this->pointingModel->toIDL());
1435 :
1436 : result->polarization = *(this->polarization->toIDL());
1437 :
1438 : result->processor = *(this->processor->toIDL());
1439 :
1440 : result->pulsar = *(this->pulsar->toIDL());
1441 :
1442 : result->receiver = *(this->receiver->toIDL());
1443 :
1444 : result->sBSummary = *(this->sBSummary->toIDL());
1445 :
1446 : result->scale = *(this->scale->toIDL());
1447 :
1448 : result->scan = *(this->scan->toIDL());
1449 :
1450 : result->seeing = *(this->seeing->toIDL());
1451 :
1452 : result->source = *(this->source->toIDL());
1453 :
1454 : result->spectralWindow = *(this->spectralWindow->toIDL());
1455 :
1456 : result->squareLawDetector = *(this->squareLawDetector->toIDL());
1457 :
1458 : result->state = *(this->state->toIDL());
1459 :
1460 : result->station = *(this->station->toIDL());
1461 :
1462 : result->subscan = *(this->subscan->toIDL());
1463 :
1464 : result->switchCycle = *(this->switchCycle->toIDL());
1465 :
1466 : result->sysCal = *(this->sysCal->toIDL());
1467 :
1468 : result->sysPower = *(this->sysPower->toIDL());
1469 :
1470 : result->totalPower = *(this->totalPower->toIDL());
1471 :
1472 : result->vLAWVR = *(this->vLAWVR->toIDL());
1473 :
1474 : result->wVMCal = *(this->wVMCal->toIDL());
1475 :
1476 : result->weather = *(this->weather->toIDL());
1477 :
1478 : return result;
1479 : }
1480 :
1481 : void ASDM::fromIDL(ASDMDataSetIDL* x) {
1482 :
1483 : this->main->fromIDL(x->main);
1484 :
1485 : this->almaRadiometer->fromIDL(x->almaRadiometer);
1486 :
1487 : this->annotation->fromIDL(x->annotation);
1488 :
1489 : this->antenna->fromIDL(x->antenna);
1490 :
1491 : this->calAmpli->fromIDL(x->calAmpli);
1492 :
1493 : this->calAntennaSolutions->fromIDL(x->calAntennaSolutions);
1494 :
1495 : this->calAppPhase->fromIDL(x->calAppPhase);
1496 :
1497 : this->calAtmosphere->fromIDL(x->calAtmosphere);
1498 :
1499 : this->calBandpass->fromIDL(x->calBandpass);
1500 :
1501 : this->calCurve->fromIDL(x->calCurve);
1502 :
1503 : this->calData->fromIDL(x->calData);
1504 :
1505 : this->calDelay->fromIDL(x->calDelay);
1506 :
1507 : this->calDevice->fromIDL(x->calDevice);
1508 :
1509 : this->calFlux->fromIDL(x->calFlux);
1510 :
1511 : this->calFocus->fromIDL(x->calFocus);
1512 :
1513 : this->calFocusModel->fromIDL(x->calFocusModel);
1514 :
1515 : this->calGain->fromIDL(x->calGain);
1516 :
1517 : this->calHolography->fromIDL(x->calHolography);
1518 :
1519 : this->calPhase->fromIDL(x->calPhase);
1520 :
1521 : this->calPointing->fromIDL(x->calPointing);
1522 :
1523 : this->calPointingModel->fromIDL(x->calPointingModel);
1524 :
1525 : this->calPosition->fromIDL(x->calPosition);
1526 :
1527 : this->calPrimaryBeam->fromIDL(x->calPrimaryBeam);
1528 :
1529 : this->calReduction->fromIDL(x->calReduction);
1530 :
1531 : this->calSeeing->fromIDL(x->calSeeing);
1532 :
1533 : this->calWVR->fromIDL(x->calWVR);
1534 :
1535 : this->configDescription->fromIDL(x->configDescription);
1536 :
1537 : this->correlatorMode->fromIDL(x->correlatorMode);
1538 :
1539 : this->dataDescription->fromIDL(x->dataDescription);
1540 :
1541 : this->delayModel->fromIDL(x->delayModel);
1542 :
1543 : this->delayModelFixedParameters->fromIDL(x->delayModelFixedParameters);
1544 :
1545 : this->delayModelVariableParameters->fromIDL(x->delayModelVariableParameters);
1546 :
1547 : this->doppler->fromIDL(x->doppler);
1548 :
1549 : this->ephemeris->fromIDL(x->ephemeris);
1550 :
1551 : this->execBlock->fromIDL(x->execBlock);
1552 :
1553 : this->feed->fromIDL(x->feed);
1554 :
1555 : this->field->fromIDL(x->field);
1556 :
1557 : this->flag->fromIDL(x->flag);
1558 :
1559 : this->flagCmd->fromIDL(x->flagCmd);
1560 :
1561 : this->focus->fromIDL(x->focus);
1562 :
1563 : this->focusModel->fromIDL(x->focusModel);
1564 :
1565 : this->freqOffset->fromIDL(x->freqOffset);
1566 :
1567 : this->gainTracking->fromIDL(x->gainTracking);
1568 :
1569 : this->history->fromIDL(x->history);
1570 :
1571 : this->holography->fromIDL(x->holography);
1572 :
1573 : this->observation->fromIDL(x->observation);
1574 :
1575 : this->pointing->fromIDL(x->pointing);
1576 :
1577 : this->pointingModel->fromIDL(x->pointingModel);
1578 :
1579 : this->polarization->fromIDL(x->polarization);
1580 :
1581 : this->processor->fromIDL(x->processor);
1582 :
1583 : this->pulsar->fromIDL(x->pulsar);
1584 :
1585 : this->receiver->fromIDL(x->receiver);
1586 :
1587 : this->sBSummary->fromIDL(x->sBSummary);
1588 :
1589 : this->scale->fromIDL(x->scale);
1590 :
1591 : this->scan->fromIDL(x->scan);
1592 :
1593 : this->seeing->fromIDL(x->seeing);
1594 :
1595 : this->source->fromIDL(x->source);
1596 :
1597 : this->spectralWindow->fromIDL(x->spectralWindow);
1598 :
1599 : this->squareLawDetector->fromIDL(x->squareLawDetector);
1600 :
1601 : this->state->fromIDL(x->state);
1602 :
1603 : this->station->fromIDL(x->station);
1604 :
1605 : this->subscan->fromIDL(x->subscan);
1606 :
1607 : this->switchCycle->fromIDL(x->switchCycle);
1608 :
1609 : this->sysCal->fromIDL(x->sysCal);
1610 :
1611 : this->sysPower->fromIDL(x->sysPower);
1612 :
1613 : this->totalPower->fromIDL(x->totalPower);
1614 :
1615 : this->vLAWVR->fromIDL(x->vLAWVR);
1616 :
1617 : this->wVMCal->fromIDL(x->wVMCal);
1618 :
1619 : this->weather->fromIDL(x->weather);
1620 :
1621 : }
1622 : #endif
1623 :
1624 : /**
1625 : * Write this ASDM dataset to the specified directory
1626 : * as a collection of XML documents.
1627 : * @param directory The directory to which this dataset is written.
1628 : * @throws ConversionException If any error occurs in converting the
1629 : * table to XML and writing it to the directory. This method will
1630 : * not overwrite any existing file; a ConversionException is also
1631 : * thrown in this case.
1632 : */
1633 0 : void ASDM::toXML(string directory) const {
1634 :
1635 0 : if (!directoryExists(directory.c_str()) &&
1636 0 : !createPath(directory.c_str())) {
1637 0 : throw ConversionException("Could not create directory " , directory);
1638 : }
1639 :
1640 : /*
1641 : if (mkdir(directory.c_str(), S_IRWXU) == -1)
1642 : throw ConversionException("Could not create directory ", directory);
1643 : */
1644 :
1645 0 : string containername = directory + "/ASDM.xml";
1646 0 : ofstream out(containername.c_str(),ios::out|ios::trunc);
1647 0 : if (out.rdstate() == ostream::failbit)
1648 0 : throw ConversionException("Could not open file " + containername + " for writing","ASDM");
1649 0 : out << toXML() << endl;
1650 0 : out.close();
1651 0 : if (out.rdstate() == ostream::failbit)
1652 0 : throw ConversionException("Could not close file " + containername,"ASDM");
1653 0 : for (unsigned int i = 0; i < table.size(); ++i) {
1654 0 : if (table[i]->size() == 0)
1655 0 : continue; // Skip any empty table.
1656 0 : string tablename = directory + "/" + table[i]->getName() + ".xml";
1657 0 : ofstream tableout(tablename.c_str(),ios::out|ios::trunc);
1658 0 : if (tableout.rdstate() == ostream::failbit)
1659 0 : throw ConversionException("Could not open file " + tablename + " for writing",table[i]->getName());
1660 0 : tableout << table[i]->toXML() << endl;
1661 0 : tableout.close();
1662 0 : if (tableout.rdstate() == ostream::failbit)
1663 0 : throw ConversionException("Could not close file " + tablename,table[i]->getName());
1664 : }
1665 0 : }
1666 :
1667 : /**
1668 : * Get an ASDM dataset, given the full path name of the
1669 : * directory containing the XML version of the dataset.
1670 : * @param xmlDirectory The full path name of the directory
1671 : * containing this dataset.
1672 : * @return The complete dataset that belongs to the container
1673 : * in this directory.
1674 : * @throws ConversionException If any error occurs reading the
1675 : * files in the directory or in converting the tables from XML.
1676 : */
1677 0 : ASDM *ASDM::getFromXML(string xmlDirectory) {
1678 0 : string containername = xmlDirectory + "/ASDM.xml";
1679 0 : ifstream in(containername.c_str(),ios::in);
1680 0 : if (in.rdstate() == istream::failbit)
1681 0 : throw ConversionException("Could not open file " + containername + " for reading","ASDM");
1682 0 : string xmlDoc;
1683 0 : const int SIZE = 4096*1024;
1684 : char line[SIZE];
1685 0 : while (in.getline(line,SIZE)) {
1686 0 : if (in.rdstate() == istream::failbit || in.rdstate() == istream::badbit) {
1687 0 : throw ConversionException("Error reading file " + containername,"ASDM");
1688 : };
1689 0 : xmlDoc.append(line);
1690 : }
1691 0 : in.close();
1692 0 : if (in.rdstate() == istream::failbit)
1693 0 : throw ConversionException("Could not close file " + containername,"ASDM");
1694 0 : ASDM *dataset = new ASDM ();
1695 0 : dataset->fromXML(xmlDoc);
1696 : // Now, do each table.
1697 0 : int BLOCKSIZE = 1000000;
1698 0 : char c[BLOCKSIZE];
1699 0 : Entity entity;
1700 :
1701 0 : entity = dataset->tableEntity["Main"];
1702 0 : if (entity.getEntityId().getId().length() != 0) {
1703 : // Which file must we read ?
1704 0 : string tablename = xmlDirectory + "/Main.xml";
1705 :
1706 : // Determine the file size
1707 0 : ifstream::pos_type size;
1708 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
1709 0 : if (tablein.is_open()) {
1710 0 : size = tablein.tellg();
1711 : }
1712 : else {
1713 0 : throw ConversionException("Could not open file " + tablename, "Main");
1714 : }
1715 :
1716 : // Read the file in a string
1717 0 : string tableDoc;
1718 :
1719 0 : tableDoc.reserve(size);
1720 0 : tablein.seekg (0);
1721 0 : int nread = BLOCKSIZE;
1722 0 : while (nread == BLOCKSIZE) {
1723 0 : tablein.read(c, BLOCKSIZE);
1724 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
1725 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
1726 : }
1727 0 : nread = tablein.gcount();
1728 0 : tableDoc.append(c, nread);
1729 : }
1730 0 : tablein.close();
1731 0 : if (tablein.rdstate() == istream::failbit)
1732 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
1733 :
1734 : // And finally parse the XML document to populate the table.
1735 0 : dataset->getMain().fromXML(tableDoc);
1736 : }
1737 :
1738 0 : entity = dataset->tableEntity["AlmaRadiometer"];
1739 0 : if (entity.getEntityId().getId().length() != 0) {
1740 : // Which file must we read ?
1741 0 : string tablename = xmlDirectory + "/AlmaRadiometer.xml";
1742 :
1743 : // Determine the file size
1744 0 : ifstream::pos_type size;
1745 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
1746 0 : if (tablein.is_open()) {
1747 0 : size = tablein.tellg();
1748 : }
1749 : else {
1750 0 : throw ConversionException("Could not open file " + tablename, "AlmaRadiometer");
1751 : }
1752 :
1753 : // Read the file in a string
1754 0 : string tableDoc;
1755 :
1756 0 : tableDoc.reserve(size);
1757 0 : tablein.seekg (0);
1758 0 : int nread = BLOCKSIZE;
1759 0 : while (nread == BLOCKSIZE) {
1760 0 : tablein.read(c, BLOCKSIZE);
1761 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
1762 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
1763 : }
1764 0 : nread = tablein.gcount();
1765 0 : tableDoc.append(c, nread);
1766 : }
1767 0 : tablein.close();
1768 0 : if (tablein.rdstate() == istream::failbit)
1769 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
1770 :
1771 : // And finally parse the XML document to populate the table.
1772 0 : dataset->getAlmaRadiometer().fromXML(tableDoc);
1773 : }
1774 :
1775 0 : entity = dataset->tableEntity["Annotation"];
1776 0 : if (entity.getEntityId().getId().length() != 0) {
1777 : // Which file must we read ?
1778 0 : string tablename = xmlDirectory + "/Annotation.xml";
1779 :
1780 : // Determine the file size
1781 0 : ifstream::pos_type size;
1782 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
1783 0 : if (tablein.is_open()) {
1784 0 : size = tablein.tellg();
1785 : }
1786 : else {
1787 0 : throw ConversionException("Could not open file " + tablename, "Annotation");
1788 : }
1789 :
1790 : // Read the file in a string
1791 0 : string tableDoc;
1792 :
1793 0 : tableDoc.reserve(size);
1794 0 : tablein.seekg (0);
1795 0 : int nread = BLOCKSIZE;
1796 0 : while (nread == BLOCKSIZE) {
1797 0 : tablein.read(c, BLOCKSIZE);
1798 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
1799 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
1800 : }
1801 0 : nread = tablein.gcount();
1802 0 : tableDoc.append(c, nread);
1803 : }
1804 0 : tablein.close();
1805 0 : if (tablein.rdstate() == istream::failbit)
1806 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
1807 :
1808 : // And finally parse the XML document to populate the table.
1809 0 : dataset->getAnnotation().fromXML(tableDoc);
1810 : }
1811 :
1812 0 : entity = dataset->tableEntity["Antenna"];
1813 0 : if (entity.getEntityId().getId().length() != 0) {
1814 : // Which file must we read ?
1815 0 : string tablename = xmlDirectory + "/Antenna.xml";
1816 :
1817 : // Determine the file size
1818 0 : ifstream::pos_type size;
1819 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
1820 0 : if (tablein.is_open()) {
1821 0 : size = tablein.tellg();
1822 : }
1823 : else {
1824 0 : throw ConversionException("Could not open file " + tablename, "Antenna");
1825 : }
1826 :
1827 : // Read the file in a string
1828 0 : string tableDoc;
1829 :
1830 0 : tableDoc.reserve(size);
1831 0 : tablein.seekg (0);
1832 0 : int nread = BLOCKSIZE;
1833 0 : while (nread == BLOCKSIZE) {
1834 0 : tablein.read(c, BLOCKSIZE);
1835 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
1836 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
1837 : }
1838 0 : nread = tablein.gcount();
1839 0 : tableDoc.append(c, nread);
1840 : }
1841 0 : tablein.close();
1842 0 : if (tablein.rdstate() == istream::failbit)
1843 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
1844 :
1845 : // And finally parse the XML document to populate the table.
1846 0 : dataset->getAntenna().fromXML(tableDoc);
1847 : }
1848 :
1849 0 : entity = dataset->tableEntity["CalAmpli"];
1850 0 : if (entity.getEntityId().getId().length() != 0) {
1851 : // Which file must we read ?
1852 0 : string tablename = xmlDirectory + "/CalAmpli.xml";
1853 :
1854 : // Determine the file size
1855 0 : ifstream::pos_type size;
1856 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
1857 0 : if (tablein.is_open()) {
1858 0 : size = tablein.tellg();
1859 : }
1860 : else {
1861 0 : throw ConversionException("Could not open file " + tablename, "CalAmpli");
1862 : }
1863 :
1864 : // Read the file in a string
1865 0 : string tableDoc;
1866 :
1867 0 : tableDoc.reserve(size);
1868 0 : tablein.seekg (0);
1869 0 : int nread = BLOCKSIZE;
1870 0 : while (nread == BLOCKSIZE) {
1871 0 : tablein.read(c, BLOCKSIZE);
1872 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
1873 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
1874 : }
1875 0 : nread = tablein.gcount();
1876 0 : tableDoc.append(c, nread);
1877 : }
1878 0 : tablein.close();
1879 0 : if (tablein.rdstate() == istream::failbit)
1880 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
1881 :
1882 : // And finally parse the XML document to populate the table.
1883 0 : dataset->getCalAmpli().fromXML(tableDoc);
1884 : }
1885 :
1886 0 : entity = dataset->tableEntity["CalAntennaSolutions"];
1887 0 : if (entity.getEntityId().getId().length() != 0) {
1888 : // Which file must we read ?
1889 0 : string tablename = xmlDirectory + "/CalAntennaSolutions.xml";
1890 :
1891 : // Determine the file size
1892 0 : ifstream::pos_type size;
1893 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
1894 0 : if (tablein.is_open()) {
1895 0 : size = tablein.tellg();
1896 : }
1897 : else {
1898 0 : throw ConversionException("Could not open file " + tablename, "CalAntennaSolutions");
1899 : }
1900 :
1901 : // Read the file in a string
1902 0 : string tableDoc;
1903 :
1904 0 : tableDoc.reserve(size);
1905 0 : tablein.seekg (0);
1906 0 : int nread = BLOCKSIZE;
1907 0 : while (nread == BLOCKSIZE) {
1908 0 : tablein.read(c, BLOCKSIZE);
1909 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
1910 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
1911 : }
1912 0 : nread = tablein.gcount();
1913 0 : tableDoc.append(c, nread);
1914 : }
1915 0 : tablein.close();
1916 0 : if (tablein.rdstate() == istream::failbit)
1917 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
1918 :
1919 : // And finally parse the XML document to populate the table.
1920 0 : dataset->getCalAntennaSolutions().fromXML(tableDoc);
1921 : }
1922 :
1923 0 : entity = dataset->tableEntity["CalAppPhase"];
1924 0 : if (entity.getEntityId().getId().length() != 0) {
1925 : // Which file must we read ?
1926 0 : string tablename = xmlDirectory + "/CalAppPhase.xml";
1927 :
1928 : // Determine the file size
1929 0 : ifstream::pos_type size;
1930 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
1931 0 : if (tablein.is_open()) {
1932 0 : size = tablein.tellg();
1933 : }
1934 : else {
1935 0 : throw ConversionException("Could not open file " + tablename, "CalAppPhase");
1936 : }
1937 :
1938 : // Read the file in a string
1939 0 : string tableDoc;
1940 :
1941 0 : tableDoc.reserve(size);
1942 0 : tablein.seekg (0);
1943 0 : int nread = BLOCKSIZE;
1944 0 : while (nread == BLOCKSIZE) {
1945 0 : tablein.read(c, BLOCKSIZE);
1946 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
1947 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
1948 : }
1949 0 : nread = tablein.gcount();
1950 0 : tableDoc.append(c, nread);
1951 : }
1952 0 : tablein.close();
1953 0 : if (tablein.rdstate() == istream::failbit)
1954 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
1955 :
1956 : // And finally parse the XML document to populate the table.
1957 0 : dataset->getCalAppPhase().fromXML(tableDoc);
1958 : }
1959 :
1960 0 : entity = dataset->tableEntity["CalAtmosphere"];
1961 0 : if (entity.getEntityId().getId().length() != 0) {
1962 : // Which file must we read ?
1963 0 : string tablename = xmlDirectory + "/CalAtmosphere.xml";
1964 :
1965 : // Determine the file size
1966 0 : ifstream::pos_type size;
1967 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
1968 0 : if (tablein.is_open()) {
1969 0 : size = tablein.tellg();
1970 : }
1971 : else {
1972 0 : throw ConversionException("Could not open file " + tablename, "CalAtmosphere");
1973 : }
1974 :
1975 : // Read the file in a string
1976 0 : string tableDoc;
1977 :
1978 0 : tableDoc.reserve(size);
1979 0 : tablein.seekg (0);
1980 0 : int nread = BLOCKSIZE;
1981 0 : while (nread == BLOCKSIZE) {
1982 0 : tablein.read(c, BLOCKSIZE);
1983 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
1984 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
1985 : }
1986 0 : nread = tablein.gcount();
1987 0 : tableDoc.append(c, nread);
1988 : }
1989 0 : tablein.close();
1990 0 : if (tablein.rdstate() == istream::failbit)
1991 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
1992 :
1993 : // And finally parse the XML document to populate the table.
1994 0 : dataset->getCalAtmosphere().fromXML(tableDoc);
1995 : }
1996 :
1997 0 : entity = dataset->tableEntity["CalBandpass"];
1998 0 : if (entity.getEntityId().getId().length() != 0) {
1999 : // Which file must we read ?
2000 0 : string tablename = xmlDirectory + "/CalBandpass.xml";
2001 :
2002 : // Determine the file size
2003 0 : ifstream::pos_type size;
2004 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2005 0 : if (tablein.is_open()) {
2006 0 : size = tablein.tellg();
2007 : }
2008 : else {
2009 0 : throw ConversionException("Could not open file " + tablename, "CalBandpass");
2010 : }
2011 :
2012 : // Read the file in a string
2013 0 : string tableDoc;
2014 :
2015 0 : tableDoc.reserve(size);
2016 0 : tablein.seekg (0);
2017 0 : int nread = BLOCKSIZE;
2018 0 : while (nread == BLOCKSIZE) {
2019 0 : tablein.read(c, BLOCKSIZE);
2020 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2021 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2022 : }
2023 0 : nread = tablein.gcount();
2024 0 : tableDoc.append(c, nread);
2025 : }
2026 0 : tablein.close();
2027 0 : if (tablein.rdstate() == istream::failbit)
2028 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2029 :
2030 : // And finally parse the XML document to populate the table.
2031 0 : dataset->getCalBandpass().fromXML(tableDoc);
2032 : }
2033 :
2034 0 : entity = dataset->tableEntity["CalCurve"];
2035 0 : if (entity.getEntityId().getId().length() != 0) {
2036 : // Which file must we read ?
2037 0 : string tablename = xmlDirectory + "/CalCurve.xml";
2038 :
2039 : // Determine the file size
2040 0 : ifstream::pos_type size;
2041 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2042 0 : if (tablein.is_open()) {
2043 0 : size = tablein.tellg();
2044 : }
2045 : else {
2046 0 : throw ConversionException("Could not open file " + tablename, "CalCurve");
2047 : }
2048 :
2049 : // Read the file in a string
2050 0 : string tableDoc;
2051 :
2052 0 : tableDoc.reserve(size);
2053 0 : tablein.seekg (0);
2054 0 : int nread = BLOCKSIZE;
2055 0 : while (nread == BLOCKSIZE) {
2056 0 : tablein.read(c, BLOCKSIZE);
2057 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2058 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2059 : }
2060 0 : nread = tablein.gcount();
2061 0 : tableDoc.append(c, nread);
2062 : }
2063 0 : tablein.close();
2064 0 : if (tablein.rdstate() == istream::failbit)
2065 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2066 :
2067 : // And finally parse the XML document to populate the table.
2068 0 : dataset->getCalCurve().fromXML(tableDoc);
2069 : }
2070 :
2071 0 : entity = dataset->tableEntity["CalData"];
2072 0 : if (entity.getEntityId().getId().length() != 0) {
2073 : // Which file must we read ?
2074 0 : string tablename = xmlDirectory + "/CalData.xml";
2075 :
2076 : // Determine the file size
2077 0 : ifstream::pos_type size;
2078 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2079 0 : if (tablein.is_open()) {
2080 0 : size = tablein.tellg();
2081 : }
2082 : else {
2083 0 : throw ConversionException("Could not open file " + tablename, "CalData");
2084 : }
2085 :
2086 : // Read the file in a string
2087 0 : string tableDoc;
2088 :
2089 0 : tableDoc.reserve(size);
2090 0 : tablein.seekg (0);
2091 0 : int nread = BLOCKSIZE;
2092 0 : while (nread == BLOCKSIZE) {
2093 0 : tablein.read(c, BLOCKSIZE);
2094 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2095 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2096 : }
2097 0 : nread = tablein.gcount();
2098 0 : tableDoc.append(c, nread);
2099 : }
2100 0 : tablein.close();
2101 0 : if (tablein.rdstate() == istream::failbit)
2102 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2103 :
2104 : // And finally parse the XML document to populate the table.
2105 0 : dataset->getCalData().fromXML(tableDoc);
2106 : }
2107 :
2108 0 : entity = dataset->tableEntity["CalDelay"];
2109 0 : if (entity.getEntityId().getId().length() != 0) {
2110 : // Which file must we read ?
2111 0 : string tablename = xmlDirectory + "/CalDelay.xml";
2112 :
2113 : // Determine the file size
2114 0 : ifstream::pos_type size;
2115 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2116 0 : if (tablein.is_open()) {
2117 0 : size = tablein.tellg();
2118 : }
2119 : else {
2120 0 : throw ConversionException("Could not open file " + tablename, "CalDelay");
2121 : }
2122 :
2123 : // Read the file in a string
2124 0 : string tableDoc;
2125 :
2126 0 : tableDoc.reserve(size);
2127 0 : tablein.seekg (0);
2128 0 : int nread = BLOCKSIZE;
2129 0 : while (nread == BLOCKSIZE) {
2130 0 : tablein.read(c, BLOCKSIZE);
2131 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2132 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2133 : }
2134 0 : nread = tablein.gcount();
2135 0 : tableDoc.append(c, nread);
2136 : }
2137 0 : tablein.close();
2138 0 : if (tablein.rdstate() == istream::failbit)
2139 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2140 :
2141 : // And finally parse the XML document to populate the table.
2142 0 : dataset->getCalDelay().fromXML(tableDoc);
2143 : }
2144 :
2145 0 : entity = dataset->tableEntity["CalDevice"];
2146 0 : if (entity.getEntityId().getId().length() != 0) {
2147 : // Which file must we read ?
2148 0 : string tablename = xmlDirectory + "/CalDevice.xml";
2149 :
2150 : // Determine the file size
2151 0 : ifstream::pos_type size;
2152 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2153 0 : if (tablein.is_open()) {
2154 0 : size = tablein.tellg();
2155 : }
2156 : else {
2157 0 : throw ConversionException("Could not open file " + tablename, "CalDevice");
2158 : }
2159 :
2160 : // Read the file in a string
2161 0 : string tableDoc;
2162 :
2163 0 : tableDoc.reserve(size);
2164 0 : tablein.seekg (0);
2165 0 : int nread = BLOCKSIZE;
2166 0 : while (nread == BLOCKSIZE) {
2167 0 : tablein.read(c, BLOCKSIZE);
2168 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2169 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2170 : }
2171 0 : nread = tablein.gcount();
2172 0 : tableDoc.append(c, nread);
2173 : }
2174 0 : tablein.close();
2175 0 : if (tablein.rdstate() == istream::failbit)
2176 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2177 :
2178 : // And finally parse the XML document to populate the table.
2179 0 : dataset->getCalDevice().fromXML(tableDoc);
2180 : }
2181 :
2182 0 : entity = dataset->tableEntity["CalFlux"];
2183 0 : if (entity.getEntityId().getId().length() != 0) {
2184 : // Which file must we read ?
2185 0 : string tablename = xmlDirectory + "/CalFlux.xml";
2186 :
2187 : // Determine the file size
2188 0 : ifstream::pos_type size;
2189 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2190 0 : if (tablein.is_open()) {
2191 0 : size = tablein.tellg();
2192 : }
2193 : else {
2194 0 : throw ConversionException("Could not open file " + tablename, "CalFlux");
2195 : }
2196 :
2197 : // Read the file in a string
2198 0 : string tableDoc;
2199 :
2200 0 : tableDoc.reserve(size);
2201 0 : tablein.seekg (0);
2202 0 : int nread = BLOCKSIZE;
2203 0 : while (nread == BLOCKSIZE) {
2204 0 : tablein.read(c, BLOCKSIZE);
2205 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2206 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2207 : }
2208 0 : nread = tablein.gcount();
2209 0 : tableDoc.append(c, nread);
2210 : }
2211 0 : tablein.close();
2212 0 : if (tablein.rdstate() == istream::failbit)
2213 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2214 :
2215 : // And finally parse the XML document to populate the table.
2216 0 : dataset->getCalFlux().fromXML(tableDoc);
2217 : }
2218 :
2219 0 : entity = dataset->tableEntity["CalFocus"];
2220 0 : if (entity.getEntityId().getId().length() != 0) {
2221 : // Which file must we read ?
2222 0 : string tablename = xmlDirectory + "/CalFocus.xml";
2223 :
2224 : // Determine the file size
2225 0 : ifstream::pos_type size;
2226 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2227 0 : if (tablein.is_open()) {
2228 0 : size = tablein.tellg();
2229 : }
2230 : else {
2231 0 : throw ConversionException("Could not open file " + tablename, "CalFocus");
2232 : }
2233 :
2234 : // Read the file in a string
2235 0 : string tableDoc;
2236 :
2237 0 : tableDoc.reserve(size);
2238 0 : tablein.seekg (0);
2239 0 : int nread = BLOCKSIZE;
2240 0 : while (nread == BLOCKSIZE) {
2241 0 : tablein.read(c, BLOCKSIZE);
2242 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2243 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2244 : }
2245 0 : nread = tablein.gcount();
2246 0 : tableDoc.append(c, nread);
2247 : }
2248 0 : tablein.close();
2249 0 : if (tablein.rdstate() == istream::failbit)
2250 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2251 :
2252 : // And finally parse the XML document to populate the table.
2253 0 : dataset->getCalFocus().fromXML(tableDoc);
2254 : }
2255 :
2256 0 : entity = dataset->tableEntity["CalFocusModel"];
2257 0 : if (entity.getEntityId().getId().length() != 0) {
2258 : // Which file must we read ?
2259 0 : string tablename = xmlDirectory + "/CalFocusModel.xml";
2260 :
2261 : // Determine the file size
2262 0 : ifstream::pos_type size;
2263 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2264 0 : if (tablein.is_open()) {
2265 0 : size = tablein.tellg();
2266 : }
2267 : else {
2268 0 : throw ConversionException("Could not open file " + tablename, "CalFocusModel");
2269 : }
2270 :
2271 : // Read the file in a string
2272 0 : string tableDoc;
2273 :
2274 0 : tableDoc.reserve(size);
2275 0 : tablein.seekg (0);
2276 0 : int nread = BLOCKSIZE;
2277 0 : while (nread == BLOCKSIZE) {
2278 0 : tablein.read(c, BLOCKSIZE);
2279 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2280 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2281 : }
2282 0 : nread = tablein.gcount();
2283 0 : tableDoc.append(c, nread);
2284 : }
2285 0 : tablein.close();
2286 0 : if (tablein.rdstate() == istream::failbit)
2287 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2288 :
2289 : // And finally parse the XML document to populate the table.
2290 0 : dataset->getCalFocusModel().fromXML(tableDoc);
2291 : }
2292 :
2293 0 : entity = dataset->tableEntity["CalGain"];
2294 0 : if (entity.getEntityId().getId().length() != 0) {
2295 : // Which file must we read ?
2296 0 : string tablename = xmlDirectory + "/CalGain.xml";
2297 :
2298 : // Determine the file size
2299 0 : ifstream::pos_type size;
2300 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2301 0 : if (tablein.is_open()) {
2302 0 : size = tablein.tellg();
2303 : }
2304 : else {
2305 0 : throw ConversionException("Could not open file " + tablename, "CalGain");
2306 : }
2307 :
2308 : // Read the file in a string
2309 0 : string tableDoc;
2310 :
2311 0 : tableDoc.reserve(size);
2312 0 : tablein.seekg (0);
2313 0 : int nread = BLOCKSIZE;
2314 0 : while (nread == BLOCKSIZE) {
2315 0 : tablein.read(c, BLOCKSIZE);
2316 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2317 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2318 : }
2319 0 : nread = tablein.gcount();
2320 0 : tableDoc.append(c, nread);
2321 : }
2322 0 : tablein.close();
2323 0 : if (tablein.rdstate() == istream::failbit)
2324 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2325 :
2326 : // And finally parse the XML document to populate the table.
2327 0 : dataset->getCalGain().fromXML(tableDoc);
2328 : }
2329 :
2330 0 : entity = dataset->tableEntity["CalHolography"];
2331 0 : if (entity.getEntityId().getId().length() != 0) {
2332 : // Which file must we read ?
2333 0 : string tablename = xmlDirectory + "/CalHolography.xml";
2334 :
2335 : // Determine the file size
2336 0 : ifstream::pos_type size;
2337 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2338 0 : if (tablein.is_open()) {
2339 0 : size = tablein.tellg();
2340 : }
2341 : else {
2342 0 : throw ConversionException("Could not open file " + tablename, "CalHolography");
2343 : }
2344 :
2345 : // Read the file in a string
2346 0 : string tableDoc;
2347 :
2348 0 : tableDoc.reserve(size);
2349 0 : tablein.seekg (0);
2350 0 : int nread = BLOCKSIZE;
2351 0 : while (nread == BLOCKSIZE) {
2352 0 : tablein.read(c, BLOCKSIZE);
2353 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2354 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2355 : }
2356 0 : nread = tablein.gcount();
2357 0 : tableDoc.append(c, nread);
2358 : }
2359 0 : tablein.close();
2360 0 : if (tablein.rdstate() == istream::failbit)
2361 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2362 :
2363 : // And finally parse the XML document to populate the table.
2364 0 : dataset->getCalHolography().fromXML(tableDoc);
2365 : }
2366 :
2367 0 : entity = dataset->tableEntity["CalPhase"];
2368 0 : if (entity.getEntityId().getId().length() != 0) {
2369 : // Which file must we read ?
2370 0 : string tablename = xmlDirectory + "/CalPhase.xml";
2371 :
2372 : // Determine the file size
2373 0 : ifstream::pos_type size;
2374 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2375 0 : if (tablein.is_open()) {
2376 0 : size = tablein.tellg();
2377 : }
2378 : else {
2379 0 : throw ConversionException("Could not open file " + tablename, "CalPhase");
2380 : }
2381 :
2382 : // Read the file in a string
2383 0 : string tableDoc;
2384 :
2385 0 : tableDoc.reserve(size);
2386 0 : tablein.seekg (0);
2387 0 : int nread = BLOCKSIZE;
2388 0 : while (nread == BLOCKSIZE) {
2389 0 : tablein.read(c, BLOCKSIZE);
2390 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2391 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2392 : }
2393 0 : nread = tablein.gcount();
2394 0 : tableDoc.append(c, nread);
2395 : }
2396 0 : tablein.close();
2397 0 : if (tablein.rdstate() == istream::failbit)
2398 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2399 :
2400 : // And finally parse the XML document to populate the table.
2401 0 : dataset->getCalPhase().fromXML(tableDoc);
2402 : }
2403 :
2404 0 : entity = dataset->tableEntity["CalPointing"];
2405 0 : if (entity.getEntityId().getId().length() != 0) {
2406 : // Which file must we read ?
2407 0 : string tablename = xmlDirectory + "/CalPointing.xml";
2408 :
2409 : // Determine the file size
2410 0 : ifstream::pos_type size;
2411 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2412 0 : if (tablein.is_open()) {
2413 0 : size = tablein.tellg();
2414 : }
2415 : else {
2416 0 : throw ConversionException("Could not open file " + tablename, "CalPointing");
2417 : }
2418 :
2419 : // Read the file in a string
2420 0 : string tableDoc;
2421 :
2422 0 : tableDoc.reserve(size);
2423 0 : tablein.seekg (0);
2424 0 : int nread = BLOCKSIZE;
2425 0 : while (nread == BLOCKSIZE) {
2426 0 : tablein.read(c, BLOCKSIZE);
2427 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2428 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2429 : }
2430 0 : nread = tablein.gcount();
2431 0 : tableDoc.append(c, nread);
2432 : }
2433 0 : tablein.close();
2434 0 : if (tablein.rdstate() == istream::failbit)
2435 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2436 :
2437 : // And finally parse the XML document to populate the table.
2438 0 : dataset->getCalPointing().fromXML(tableDoc);
2439 : }
2440 :
2441 0 : entity = dataset->tableEntity["CalPointingModel"];
2442 0 : if (entity.getEntityId().getId().length() != 0) {
2443 : // Which file must we read ?
2444 0 : string tablename = xmlDirectory + "/CalPointingModel.xml";
2445 :
2446 : // Determine the file size
2447 0 : ifstream::pos_type size;
2448 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2449 0 : if (tablein.is_open()) {
2450 0 : size = tablein.tellg();
2451 : }
2452 : else {
2453 0 : throw ConversionException("Could not open file " + tablename, "CalPointingModel");
2454 : }
2455 :
2456 : // Read the file in a string
2457 0 : string tableDoc;
2458 :
2459 0 : tableDoc.reserve(size);
2460 0 : tablein.seekg (0);
2461 0 : int nread = BLOCKSIZE;
2462 0 : while (nread == BLOCKSIZE) {
2463 0 : tablein.read(c, BLOCKSIZE);
2464 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2465 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2466 : }
2467 0 : nread = tablein.gcount();
2468 0 : tableDoc.append(c, nread);
2469 : }
2470 0 : tablein.close();
2471 0 : if (tablein.rdstate() == istream::failbit)
2472 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2473 :
2474 : // And finally parse the XML document to populate the table.
2475 0 : dataset->getCalPointingModel().fromXML(tableDoc);
2476 : }
2477 :
2478 0 : entity = dataset->tableEntity["CalPosition"];
2479 0 : if (entity.getEntityId().getId().length() != 0) {
2480 : // Which file must we read ?
2481 0 : string tablename = xmlDirectory + "/CalPosition.xml";
2482 :
2483 : // Determine the file size
2484 0 : ifstream::pos_type size;
2485 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2486 0 : if (tablein.is_open()) {
2487 0 : size = tablein.tellg();
2488 : }
2489 : else {
2490 0 : throw ConversionException("Could not open file " + tablename, "CalPosition");
2491 : }
2492 :
2493 : // Read the file in a string
2494 0 : string tableDoc;
2495 :
2496 0 : tableDoc.reserve(size);
2497 0 : tablein.seekg (0);
2498 0 : int nread = BLOCKSIZE;
2499 0 : while (nread == BLOCKSIZE) {
2500 0 : tablein.read(c, BLOCKSIZE);
2501 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2502 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2503 : }
2504 0 : nread = tablein.gcount();
2505 0 : tableDoc.append(c, nread);
2506 : }
2507 0 : tablein.close();
2508 0 : if (tablein.rdstate() == istream::failbit)
2509 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2510 :
2511 : // And finally parse the XML document to populate the table.
2512 0 : dataset->getCalPosition().fromXML(tableDoc);
2513 : }
2514 :
2515 0 : entity = dataset->tableEntity["CalPrimaryBeam"];
2516 0 : if (entity.getEntityId().getId().length() != 0) {
2517 : // Which file must we read ?
2518 0 : string tablename = xmlDirectory + "/CalPrimaryBeam.xml";
2519 :
2520 : // Determine the file size
2521 0 : ifstream::pos_type size;
2522 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2523 0 : if (tablein.is_open()) {
2524 0 : size = tablein.tellg();
2525 : }
2526 : else {
2527 0 : throw ConversionException("Could not open file " + tablename, "CalPrimaryBeam");
2528 : }
2529 :
2530 : // Read the file in a string
2531 0 : string tableDoc;
2532 :
2533 0 : tableDoc.reserve(size);
2534 0 : tablein.seekg (0);
2535 0 : int nread = BLOCKSIZE;
2536 0 : while (nread == BLOCKSIZE) {
2537 0 : tablein.read(c, BLOCKSIZE);
2538 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2539 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2540 : }
2541 0 : nread = tablein.gcount();
2542 0 : tableDoc.append(c, nread);
2543 : }
2544 0 : tablein.close();
2545 0 : if (tablein.rdstate() == istream::failbit)
2546 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2547 :
2548 : // And finally parse the XML document to populate the table.
2549 0 : dataset->getCalPrimaryBeam().fromXML(tableDoc);
2550 : }
2551 :
2552 0 : entity = dataset->tableEntity["CalReduction"];
2553 0 : if (entity.getEntityId().getId().length() != 0) {
2554 : // Which file must we read ?
2555 0 : string tablename = xmlDirectory + "/CalReduction.xml";
2556 :
2557 : // Determine the file size
2558 0 : ifstream::pos_type size;
2559 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2560 0 : if (tablein.is_open()) {
2561 0 : size = tablein.tellg();
2562 : }
2563 : else {
2564 0 : throw ConversionException("Could not open file " + tablename, "CalReduction");
2565 : }
2566 :
2567 : // Read the file in a string
2568 0 : string tableDoc;
2569 :
2570 0 : tableDoc.reserve(size);
2571 0 : tablein.seekg (0);
2572 0 : int nread = BLOCKSIZE;
2573 0 : while (nread == BLOCKSIZE) {
2574 0 : tablein.read(c, BLOCKSIZE);
2575 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2576 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2577 : }
2578 0 : nread = tablein.gcount();
2579 0 : tableDoc.append(c, nread);
2580 : }
2581 0 : tablein.close();
2582 0 : if (tablein.rdstate() == istream::failbit)
2583 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2584 :
2585 : // And finally parse the XML document to populate the table.
2586 0 : dataset->getCalReduction().fromXML(tableDoc);
2587 : }
2588 :
2589 0 : entity = dataset->tableEntity["CalSeeing"];
2590 0 : if (entity.getEntityId().getId().length() != 0) {
2591 : // Which file must we read ?
2592 0 : string tablename = xmlDirectory + "/CalSeeing.xml";
2593 :
2594 : // Determine the file size
2595 0 : ifstream::pos_type size;
2596 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2597 0 : if (tablein.is_open()) {
2598 0 : size = tablein.tellg();
2599 : }
2600 : else {
2601 0 : throw ConversionException("Could not open file " + tablename, "CalSeeing");
2602 : }
2603 :
2604 : // Read the file in a string
2605 0 : string tableDoc;
2606 :
2607 0 : tableDoc.reserve(size);
2608 0 : tablein.seekg (0);
2609 0 : int nread = BLOCKSIZE;
2610 0 : while (nread == BLOCKSIZE) {
2611 0 : tablein.read(c, BLOCKSIZE);
2612 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2613 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2614 : }
2615 0 : nread = tablein.gcount();
2616 0 : tableDoc.append(c, nread);
2617 : }
2618 0 : tablein.close();
2619 0 : if (tablein.rdstate() == istream::failbit)
2620 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2621 :
2622 : // And finally parse the XML document to populate the table.
2623 0 : dataset->getCalSeeing().fromXML(tableDoc);
2624 : }
2625 :
2626 0 : entity = dataset->tableEntity["CalWVR"];
2627 0 : if (entity.getEntityId().getId().length() != 0) {
2628 : // Which file must we read ?
2629 0 : string tablename = xmlDirectory + "/CalWVR.xml";
2630 :
2631 : // Determine the file size
2632 0 : ifstream::pos_type size;
2633 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2634 0 : if (tablein.is_open()) {
2635 0 : size = tablein.tellg();
2636 : }
2637 : else {
2638 0 : throw ConversionException("Could not open file " + tablename, "CalWVR");
2639 : }
2640 :
2641 : // Read the file in a string
2642 0 : string tableDoc;
2643 :
2644 0 : tableDoc.reserve(size);
2645 0 : tablein.seekg (0);
2646 0 : int nread = BLOCKSIZE;
2647 0 : while (nread == BLOCKSIZE) {
2648 0 : tablein.read(c, BLOCKSIZE);
2649 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2650 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2651 : }
2652 0 : nread = tablein.gcount();
2653 0 : tableDoc.append(c, nread);
2654 : }
2655 0 : tablein.close();
2656 0 : if (tablein.rdstate() == istream::failbit)
2657 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2658 :
2659 : // And finally parse the XML document to populate the table.
2660 0 : dataset->getCalWVR().fromXML(tableDoc);
2661 : }
2662 :
2663 0 : entity = dataset->tableEntity["ConfigDescription"];
2664 0 : if (entity.getEntityId().getId().length() != 0) {
2665 : // Which file must we read ?
2666 0 : string tablename = xmlDirectory + "/ConfigDescription.xml";
2667 :
2668 : // Determine the file size
2669 0 : ifstream::pos_type size;
2670 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2671 0 : if (tablein.is_open()) {
2672 0 : size = tablein.tellg();
2673 : }
2674 : else {
2675 0 : throw ConversionException("Could not open file " + tablename, "ConfigDescription");
2676 : }
2677 :
2678 : // Read the file in a string
2679 0 : string tableDoc;
2680 :
2681 0 : tableDoc.reserve(size);
2682 0 : tablein.seekg (0);
2683 0 : int nread = BLOCKSIZE;
2684 0 : while (nread == BLOCKSIZE) {
2685 0 : tablein.read(c, BLOCKSIZE);
2686 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2687 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2688 : }
2689 0 : nread = tablein.gcount();
2690 0 : tableDoc.append(c, nread);
2691 : }
2692 0 : tablein.close();
2693 0 : if (tablein.rdstate() == istream::failbit)
2694 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2695 :
2696 : // And finally parse the XML document to populate the table.
2697 0 : dataset->getConfigDescription().fromXML(tableDoc);
2698 : }
2699 :
2700 0 : entity = dataset->tableEntity["CorrelatorMode"];
2701 0 : if (entity.getEntityId().getId().length() != 0) {
2702 : // Which file must we read ?
2703 0 : string tablename = xmlDirectory + "/CorrelatorMode.xml";
2704 :
2705 : // Determine the file size
2706 0 : ifstream::pos_type size;
2707 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2708 0 : if (tablein.is_open()) {
2709 0 : size = tablein.tellg();
2710 : }
2711 : else {
2712 0 : throw ConversionException("Could not open file " + tablename, "CorrelatorMode");
2713 : }
2714 :
2715 : // Read the file in a string
2716 0 : string tableDoc;
2717 :
2718 0 : tableDoc.reserve(size);
2719 0 : tablein.seekg (0);
2720 0 : int nread = BLOCKSIZE;
2721 0 : while (nread == BLOCKSIZE) {
2722 0 : tablein.read(c, BLOCKSIZE);
2723 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2724 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2725 : }
2726 0 : nread = tablein.gcount();
2727 0 : tableDoc.append(c, nread);
2728 : }
2729 0 : tablein.close();
2730 0 : if (tablein.rdstate() == istream::failbit)
2731 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2732 :
2733 : // And finally parse the XML document to populate the table.
2734 0 : dataset->getCorrelatorMode().fromXML(tableDoc);
2735 : }
2736 :
2737 0 : entity = dataset->tableEntity["DataDescription"];
2738 0 : if (entity.getEntityId().getId().length() != 0) {
2739 : // Which file must we read ?
2740 0 : string tablename = xmlDirectory + "/DataDescription.xml";
2741 :
2742 : // Determine the file size
2743 0 : ifstream::pos_type size;
2744 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2745 0 : if (tablein.is_open()) {
2746 0 : size = tablein.tellg();
2747 : }
2748 : else {
2749 0 : throw ConversionException("Could not open file " + tablename, "DataDescription");
2750 : }
2751 :
2752 : // Read the file in a string
2753 0 : string tableDoc;
2754 :
2755 0 : tableDoc.reserve(size);
2756 0 : tablein.seekg (0);
2757 0 : int nread = BLOCKSIZE;
2758 0 : while (nread == BLOCKSIZE) {
2759 0 : tablein.read(c, BLOCKSIZE);
2760 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2761 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2762 : }
2763 0 : nread = tablein.gcount();
2764 0 : tableDoc.append(c, nread);
2765 : }
2766 0 : tablein.close();
2767 0 : if (tablein.rdstate() == istream::failbit)
2768 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2769 :
2770 : // And finally parse the XML document to populate the table.
2771 0 : dataset->getDataDescription().fromXML(tableDoc);
2772 : }
2773 :
2774 0 : entity = dataset->tableEntity["DelayModel"];
2775 0 : if (entity.getEntityId().getId().length() != 0) {
2776 : // Which file must we read ?
2777 0 : string tablename = xmlDirectory + "/DelayModel.xml";
2778 :
2779 : // Determine the file size
2780 0 : ifstream::pos_type size;
2781 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2782 0 : if (tablein.is_open()) {
2783 0 : size = tablein.tellg();
2784 : }
2785 : else {
2786 0 : throw ConversionException("Could not open file " + tablename, "DelayModel");
2787 : }
2788 :
2789 : // Read the file in a string
2790 0 : string tableDoc;
2791 :
2792 0 : tableDoc.reserve(size);
2793 0 : tablein.seekg (0);
2794 0 : int nread = BLOCKSIZE;
2795 0 : while (nread == BLOCKSIZE) {
2796 0 : tablein.read(c, BLOCKSIZE);
2797 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2798 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2799 : }
2800 0 : nread = tablein.gcount();
2801 0 : tableDoc.append(c, nread);
2802 : }
2803 0 : tablein.close();
2804 0 : if (tablein.rdstate() == istream::failbit)
2805 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2806 :
2807 : // And finally parse the XML document to populate the table.
2808 0 : dataset->getDelayModel().fromXML(tableDoc);
2809 : }
2810 :
2811 0 : entity = dataset->tableEntity["DelayModelFixedParameters"];
2812 0 : if (entity.getEntityId().getId().length() != 0) {
2813 : // Which file must we read ?
2814 0 : string tablename = xmlDirectory + "/DelayModelFixedParameters.xml";
2815 :
2816 : // Determine the file size
2817 0 : ifstream::pos_type size;
2818 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2819 0 : if (tablein.is_open()) {
2820 0 : size = tablein.tellg();
2821 : }
2822 : else {
2823 0 : throw ConversionException("Could not open file " + tablename, "DelayModelFixedParameters");
2824 : }
2825 :
2826 : // Read the file in a string
2827 0 : string tableDoc;
2828 :
2829 0 : tableDoc.reserve(size);
2830 0 : tablein.seekg (0);
2831 0 : int nread = BLOCKSIZE;
2832 0 : while (nread == BLOCKSIZE) {
2833 0 : tablein.read(c, BLOCKSIZE);
2834 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2835 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2836 : }
2837 0 : nread = tablein.gcount();
2838 0 : tableDoc.append(c, nread);
2839 : }
2840 0 : tablein.close();
2841 0 : if (tablein.rdstate() == istream::failbit)
2842 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2843 :
2844 : // And finally parse the XML document to populate the table.
2845 0 : dataset->getDelayModelFixedParameters().fromXML(tableDoc);
2846 : }
2847 :
2848 0 : entity = dataset->tableEntity["DelayModelVariableParameters"];
2849 0 : if (entity.getEntityId().getId().length() != 0) {
2850 : // Which file must we read ?
2851 0 : string tablename = xmlDirectory + "/DelayModelVariableParameters.xml";
2852 :
2853 : // Determine the file size
2854 0 : ifstream::pos_type size;
2855 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2856 0 : if (tablein.is_open()) {
2857 0 : size = tablein.tellg();
2858 : }
2859 : else {
2860 0 : throw ConversionException("Could not open file " + tablename, "DelayModelVariableParameters");
2861 : }
2862 :
2863 : // Read the file in a string
2864 0 : string tableDoc;
2865 :
2866 0 : tableDoc.reserve(size);
2867 0 : tablein.seekg (0);
2868 0 : int nread = BLOCKSIZE;
2869 0 : while (nread == BLOCKSIZE) {
2870 0 : tablein.read(c, BLOCKSIZE);
2871 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2872 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2873 : }
2874 0 : nread = tablein.gcount();
2875 0 : tableDoc.append(c, nread);
2876 : }
2877 0 : tablein.close();
2878 0 : if (tablein.rdstate() == istream::failbit)
2879 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2880 :
2881 : // And finally parse the XML document to populate the table.
2882 0 : dataset->getDelayModelVariableParameters().fromXML(tableDoc);
2883 : }
2884 :
2885 0 : entity = dataset->tableEntity["Doppler"];
2886 0 : if (entity.getEntityId().getId().length() != 0) {
2887 : // Which file must we read ?
2888 0 : string tablename = xmlDirectory + "/Doppler.xml";
2889 :
2890 : // Determine the file size
2891 0 : ifstream::pos_type size;
2892 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2893 0 : if (tablein.is_open()) {
2894 0 : size = tablein.tellg();
2895 : }
2896 : else {
2897 0 : throw ConversionException("Could not open file " + tablename, "Doppler");
2898 : }
2899 :
2900 : // Read the file in a string
2901 0 : string tableDoc;
2902 :
2903 0 : tableDoc.reserve(size);
2904 0 : tablein.seekg (0);
2905 0 : int nread = BLOCKSIZE;
2906 0 : while (nread == BLOCKSIZE) {
2907 0 : tablein.read(c, BLOCKSIZE);
2908 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2909 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2910 : }
2911 0 : nread = tablein.gcount();
2912 0 : tableDoc.append(c, nread);
2913 : }
2914 0 : tablein.close();
2915 0 : if (tablein.rdstate() == istream::failbit)
2916 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2917 :
2918 : // And finally parse the XML document to populate the table.
2919 0 : dataset->getDoppler().fromXML(tableDoc);
2920 : }
2921 :
2922 0 : entity = dataset->tableEntity["Ephemeris"];
2923 0 : if (entity.getEntityId().getId().length() != 0) {
2924 : // Which file must we read ?
2925 0 : string tablename = xmlDirectory + "/Ephemeris.xml";
2926 :
2927 : // Determine the file size
2928 0 : ifstream::pos_type size;
2929 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2930 0 : if (tablein.is_open()) {
2931 0 : size = tablein.tellg();
2932 : }
2933 : else {
2934 0 : throw ConversionException("Could not open file " + tablename, "Ephemeris");
2935 : }
2936 :
2937 : // Read the file in a string
2938 0 : string tableDoc;
2939 :
2940 0 : tableDoc.reserve(size);
2941 0 : tablein.seekg (0);
2942 0 : int nread = BLOCKSIZE;
2943 0 : while (nread == BLOCKSIZE) {
2944 0 : tablein.read(c, BLOCKSIZE);
2945 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2946 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2947 : }
2948 0 : nread = tablein.gcount();
2949 0 : tableDoc.append(c, nread);
2950 : }
2951 0 : tablein.close();
2952 0 : if (tablein.rdstate() == istream::failbit)
2953 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2954 :
2955 : // And finally parse the XML document to populate the table.
2956 0 : dataset->getEphemeris().fromXML(tableDoc);
2957 : }
2958 :
2959 0 : entity = dataset->tableEntity["ExecBlock"];
2960 0 : if (entity.getEntityId().getId().length() != 0) {
2961 : // Which file must we read ?
2962 0 : string tablename = xmlDirectory + "/ExecBlock.xml";
2963 :
2964 : // Determine the file size
2965 0 : ifstream::pos_type size;
2966 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
2967 0 : if (tablein.is_open()) {
2968 0 : size = tablein.tellg();
2969 : }
2970 : else {
2971 0 : throw ConversionException("Could not open file " + tablename, "ExecBlock");
2972 : }
2973 :
2974 : // Read the file in a string
2975 0 : string tableDoc;
2976 :
2977 0 : tableDoc.reserve(size);
2978 0 : tablein.seekg (0);
2979 0 : int nread = BLOCKSIZE;
2980 0 : while (nread == BLOCKSIZE) {
2981 0 : tablein.read(c, BLOCKSIZE);
2982 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
2983 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
2984 : }
2985 0 : nread = tablein.gcount();
2986 0 : tableDoc.append(c, nread);
2987 : }
2988 0 : tablein.close();
2989 0 : if (tablein.rdstate() == istream::failbit)
2990 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
2991 :
2992 : // And finally parse the XML document to populate the table.
2993 0 : dataset->getExecBlock().fromXML(tableDoc);
2994 : }
2995 :
2996 0 : entity = dataset->tableEntity["Feed"];
2997 0 : if (entity.getEntityId().getId().length() != 0) {
2998 : // Which file must we read ?
2999 0 : string tablename = xmlDirectory + "/Feed.xml";
3000 :
3001 : // Determine the file size
3002 0 : ifstream::pos_type size;
3003 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3004 0 : if (tablein.is_open()) {
3005 0 : size = tablein.tellg();
3006 : }
3007 : else {
3008 0 : throw ConversionException("Could not open file " + tablename, "Feed");
3009 : }
3010 :
3011 : // Read the file in a string
3012 0 : string tableDoc;
3013 :
3014 0 : tableDoc.reserve(size);
3015 0 : tablein.seekg (0);
3016 0 : int nread = BLOCKSIZE;
3017 0 : while (nread == BLOCKSIZE) {
3018 0 : tablein.read(c, BLOCKSIZE);
3019 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3020 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3021 : }
3022 0 : nread = tablein.gcount();
3023 0 : tableDoc.append(c, nread);
3024 : }
3025 0 : tablein.close();
3026 0 : if (tablein.rdstate() == istream::failbit)
3027 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3028 :
3029 : // And finally parse the XML document to populate the table.
3030 0 : dataset->getFeed().fromXML(tableDoc);
3031 : }
3032 :
3033 0 : entity = dataset->tableEntity["Field"];
3034 0 : if (entity.getEntityId().getId().length() != 0) {
3035 : // Which file must we read ?
3036 0 : string tablename = xmlDirectory + "/Field.xml";
3037 :
3038 : // Determine the file size
3039 0 : ifstream::pos_type size;
3040 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3041 0 : if (tablein.is_open()) {
3042 0 : size = tablein.tellg();
3043 : }
3044 : else {
3045 0 : throw ConversionException("Could not open file " + tablename, "Field");
3046 : }
3047 :
3048 : // Read the file in a string
3049 0 : string tableDoc;
3050 :
3051 0 : tableDoc.reserve(size);
3052 0 : tablein.seekg (0);
3053 0 : int nread = BLOCKSIZE;
3054 0 : while (nread == BLOCKSIZE) {
3055 0 : tablein.read(c, BLOCKSIZE);
3056 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3057 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3058 : }
3059 0 : nread = tablein.gcount();
3060 0 : tableDoc.append(c, nread);
3061 : }
3062 0 : tablein.close();
3063 0 : if (tablein.rdstate() == istream::failbit)
3064 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3065 :
3066 : // And finally parse the XML document to populate the table.
3067 0 : dataset->getField().fromXML(tableDoc);
3068 : }
3069 :
3070 0 : entity = dataset->tableEntity["Flag"];
3071 0 : if (entity.getEntityId().getId().length() != 0) {
3072 : // Which file must we read ?
3073 0 : string tablename = xmlDirectory + "/Flag.xml";
3074 :
3075 : // Determine the file size
3076 0 : ifstream::pos_type size;
3077 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3078 0 : if (tablein.is_open()) {
3079 0 : size = tablein.tellg();
3080 : }
3081 : else {
3082 0 : throw ConversionException("Could not open file " + tablename, "Flag");
3083 : }
3084 :
3085 : // Read the file in a string
3086 0 : string tableDoc;
3087 :
3088 0 : tableDoc.reserve(size);
3089 0 : tablein.seekg (0);
3090 0 : int nread = BLOCKSIZE;
3091 0 : while (nread == BLOCKSIZE) {
3092 0 : tablein.read(c, BLOCKSIZE);
3093 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3094 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3095 : }
3096 0 : nread = tablein.gcount();
3097 0 : tableDoc.append(c, nread);
3098 : }
3099 0 : tablein.close();
3100 0 : if (tablein.rdstate() == istream::failbit)
3101 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3102 :
3103 : // And finally parse the XML document to populate the table.
3104 0 : dataset->getFlag().fromXML(tableDoc);
3105 : }
3106 :
3107 0 : entity = dataset->tableEntity["FlagCmd"];
3108 0 : if (entity.getEntityId().getId().length() != 0) {
3109 : // Which file must we read ?
3110 0 : string tablename = xmlDirectory + "/FlagCmd.xml";
3111 :
3112 : // Determine the file size
3113 0 : ifstream::pos_type size;
3114 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3115 0 : if (tablein.is_open()) {
3116 0 : size = tablein.tellg();
3117 : }
3118 : else {
3119 0 : throw ConversionException("Could not open file " + tablename, "FlagCmd");
3120 : }
3121 :
3122 : // Read the file in a string
3123 0 : string tableDoc;
3124 :
3125 0 : tableDoc.reserve(size);
3126 0 : tablein.seekg (0);
3127 0 : int nread = BLOCKSIZE;
3128 0 : while (nread == BLOCKSIZE) {
3129 0 : tablein.read(c, BLOCKSIZE);
3130 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3131 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3132 : }
3133 0 : nread = tablein.gcount();
3134 0 : tableDoc.append(c, nread);
3135 : }
3136 0 : tablein.close();
3137 0 : if (tablein.rdstate() == istream::failbit)
3138 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3139 :
3140 : // And finally parse the XML document to populate the table.
3141 0 : dataset->getFlagCmd().fromXML(tableDoc);
3142 : }
3143 :
3144 0 : entity = dataset->tableEntity["Focus"];
3145 0 : if (entity.getEntityId().getId().length() != 0) {
3146 : // Which file must we read ?
3147 0 : string tablename = xmlDirectory + "/Focus.xml";
3148 :
3149 : // Determine the file size
3150 0 : ifstream::pos_type size;
3151 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3152 0 : if (tablein.is_open()) {
3153 0 : size = tablein.tellg();
3154 : }
3155 : else {
3156 0 : throw ConversionException("Could not open file " + tablename, "Focus");
3157 : }
3158 :
3159 : // Read the file in a string
3160 0 : string tableDoc;
3161 :
3162 0 : tableDoc.reserve(size);
3163 0 : tablein.seekg (0);
3164 0 : int nread = BLOCKSIZE;
3165 0 : while (nread == BLOCKSIZE) {
3166 0 : tablein.read(c, BLOCKSIZE);
3167 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3168 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3169 : }
3170 0 : nread = tablein.gcount();
3171 0 : tableDoc.append(c, nread);
3172 : }
3173 0 : tablein.close();
3174 0 : if (tablein.rdstate() == istream::failbit)
3175 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3176 :
3177 : // And finally parse the XML document to populate the table.
3178 0 : dataset->getFocus().fromXML(tableDoc);
3179 : }
3180 :
3181 0 : entity = dataset->tableEntity["FocusModel"];
3182 0 : if (entity.getEntityId().getId().length() != 0) {
3183 : // Which file must we read ?
3184 0 : string tablename = xmlDirectory + "/FocusModel.xml";
3185 :
3186 : // Determine the file size
3187 0 : ifstream::pos_type size;
3188 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3189 0 : if (tablein.is_open()) {
3190 0 : size = tablein.tellg();
3191 : }
3192 : else {
3193 0 : throw ConversionException("Could not open file " + tablename, "FocusModel");
3194 : }
3195 :
3196 : // Read the file in a string
3197 0 : string tableDoc;
3198 :
3199 0 : tableDoc.reserve(size);
3200 0 : tablein.seekg (0);
3201 0 : int nread = BLOCKSIZE;
3202 0 : while (nread == BLOCKSIZE) {
3203 0 : tablein.read(c, BLOCKSIZE);
3204 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3205 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3206 : }
3207 0 : nread = tablein.gcount();
3208 0 : tableDoc.append(c, nread);
3209 : }
3210 0 : tablein.close();
3211 0 : if (tablein.rdstate() == istream::failbit)
3212 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3213 :
3214 : // And finally parse the XML document to populate the table.
3215 0 : dataset->getFocusModel().fromXML(tableDoc);
3216 : }
3217 :
3218 0 : entity = dataset->tableEntity["FreqOffset"];
3219 0 : if (entity.getEntityId().getId().length() != 0) {
3220 : // Which file must we read ?
3221 0 : string tablename = xmlDirectory + "/FreqOffset.xml";
3222 :
3223 : // Determine the file size
3224 0 : ifstream::pos_type size;
3225 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3226 0 : if (tablein.is_open()) {
3227 0 : size = tablein.tellg();
3228 : }
3229 : else {
3230 0 : throw ConversionException("Could not open file " + tablename, "FreqOffset");
3231 : }
3232 :
3233 : // Read the file in a string
3234 0 : string tableDoc;
3235 :
3236 0 : tableDoc.reserve(size);
3237 0 : tablein.seekg (0);
3238 0 : int nread = BLOCKSIZE;
3239 0 : while (nread == BLOCKSIZE) {
3240 0 : tablein.read(c, BLOCKSIZE);
3241 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3242 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3243 : }
3244 0 : nread = tablein.gcount();
3245 0 : tableDoc.append(c, nread);
3246 : }
3247 0 : tablein.close();
3248 0 : if (tablein.rdstate() == istream::failbit)
3249 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3250 :
3251 : // And finally parse the XML document to populate the table.
3252 0 : dataset->getFreqOffset().fromXML(tableDoc);
3253 : }
3254 :
3255 0 : entity = dataset->tableEntity["GainTracking"];
3256 0 : if (entity.getEntityId().getId().length() != 0) {
3257 : // Which file must we read ?
3258 0 : string tablename = xmlDirectory + "/GainTracking.xml";
3259 :
3260 : // Determine the file size
3261 0 : ifstream::pos_type size;
3262 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3263 0 : if (tablein.is_open()) {
3264 0 : size = tablein.tellg();
3265 : }
3266 : else {
3267 0 : throw ConversionException("Could not open file " + tablename, "GainTracking");
3268 : }
3269 :
3270 : // Read the file in a string
3271 0 : string tableDoc;
3272 :
3273 0 : tableDoc.reserve(size);
3274 0 : tablein.seekg (0);
3275 0 : int nread = BLOCKSIZE;
3276 0 : while (nread == BLOCKSIZE) {
3277 0 : tablein.read(c, BLOCKSIZE);
3278 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3279 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3280 : }
3281 0 : nread = tablein.gcount();
3282 0 : tableDoc.append(c, nread);
3283 : }
3284 0 : tablein.close();
3285 0 : if (tablein.rdstate() == istream::failbit)
3286 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3287 :
3288 : // And finally parse the XML document to populate the table.
3289 0 : dataset->getGainTracking().fromXML(tableDoc);
3290 : }
3291 :
3292 0 : entity = dataset->tableEntity["History"];
3293 0 : if (entity.getEntityId().getId().length() != 0) {
3294 : // Which file must we read ?
3295 0 : string tablename = xmlDirectory + "/History.xml";
3296 :
3297 : // Determine the file size
3298 0 : ifstream::pos_type size;
3299 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3300 0 : if (tablein.is_open()) {
3301 0 : size = tablein.tellg();
3302 : }
3303 : else {
3304 0 : throw ConversionException("Could not open file " + tablename, "History");
3305 : }
3306 :
3307 : // Read the file in a string
3308 0 : string tableDoc;
3309 :
3310 0 : tableDoc.reserve(size);
3311 0 : tablein.seekg (0);
3312 0 : int nread = BLOCKSIZE;
3313 0 : while (nread == BLOCKSIZE) {
3314 0 : tablein.read(c, BLOCKSIZE);
3315 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3316 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3317 : }
3318 0 : nread = tablein.gcount();
3319 0 : tableDoc.append(c, nread);
3320 : }
3321 0 : tablein.close();
3322 0 : if (tablein.rdstate() == istream::failbit)
3323 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3324 :
3325 : // And finally parse the XML document to populate the table.
3326 0 : dataset->getHistory().fromXML(tableDoc);
3327 : }
3328 :
3329 0 : entity = dataset->tableEntity["Holography"];
3330 0 : if (entity.getEntityId().getId().length() != 0) {
3331 : // Which file must we read ?
3332 0 : string tablename = xmlDirectory + "/Holography.xml";
3333 :
3334 : // Determine the file size
3335 0 : ifstream::pos_type size;
3336 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3337 0 : if (tablein.is_open()) {
3338 0 : size = tablein.tellg();
3339 : }
3340 : else {
3341 0 : throw ConversionException("Could not open file " + tablename, "Holography");
3342 : }
3343 :
3344 : // Read the file in a string
3345 0 : string tableDoc;
3346 :
3347 0 : tableDoc.reserve(size);
3348 0 : tablein.seekg (0);
3349 0 : int nread = BLOCKSIZE;
3350 0 : while (nread == BLOCKSIZE) {
3351 0 : tablein.read(c, BLOCKSIZE);
3352 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3353 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3354 : }
3355 0 : nread = tablein.gcount();
3356 0 : tableDoc.append(c, nread);
3357 : }
3358 0 : tablein.close();
3359 0 : if (tablein.rdstate() == istream::failbit)
3360 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3361 :
3362 : // And finally parse the XML document to populate the table.
3363 0 : dataset->getHolography().fromXML(tableDoc);
3364 : }
3365 :
3366 0 : entity = dataset->tableEntity["Observation"];
3367 0 : if (entity.getEntityId().getId().length() != 0) {
3368 : // Which file must we read ?
3369 0 : string tablename = xmlDirectory + "/Observation.xml";
3370 :
3371 : // Determine the file size
3372 0 : ifstream::pos_type size;
3373 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3374 0 : if (tablein.is_open()) {
3375 0 : size = tablein.tellg();
3376 : }
3377 : else {
3378 0 : throw ConversionException("Could not open file " + tablename, "Observation");
3379 : }
3380 :
3381 : // Read the file in a string
3382 0 : string tableDoc;
3383 :
3384 0 : tableDoc.reserve(size);
3385 0 : tablein.seekg (0);
3386 0 : int nread = BLOCKSIZE;
3387 0 : while (nread == BLOCKSIZE) {
3388 0 : tablein.read(c, BLOCKSIZE);
3389 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3390 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3391 : }
3392 0 : nread = tablein.gcount();
3393 0 : tableDoc.append(c, nread);
3394 : }
3395 0 : tablein.close();
3396 0 : if (tablein.rdstate() == istream::failbit)
3397 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3398 :
3399 : // And finally parse the XML document to populate the table.
3400 0 : dataset->getObservation().fromXML(tableDoc);
3401 : }
3402 :
3403 0 : entity = dataset->tableEntity["Pointing"];
3404 0 : if (entity.getEntityId().getId().length() != 0) {
3405 : // Which file must we read ?
3406 0 : string tablename = xmlDirectory + "/Pointing.xml";
3407 :
3408 : // Determine the file size
3409 0 : ifstream::pos_type size;
3410 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3411 0 : if (tablein.is_open()) {
3412 0 : size = tablein.tellg();
3413 : }
3414 : else {
3415 0 : throw ConversionException("Could not open file " + tablename, "Pointing");
3416 : }
3417 :
3418 : // Read the file in a string
3419 0 : string tableDoc;
3420 :
3421 0 : tableDoc.reserve(size);
3422 0 : tablein.seekg (0);
3423 0 : int nread = BLOCKSIZE;
3424 0 : while (nread == BLOCKSIZE) {
3425 0 : tablein.read(c, BLOCKSIZE);
3426 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3427 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3428 : }
3429 0 : nread = tablein.gcount();
3430 0 : tableDoc.append(c, nread);
3431 : }
3432 0 : tablein.close();
3433 0 : if (tablein.rdstate() == istream::failbit)
3434 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3435 :
3436 : // And finally parse the XML document to populate the table.
3437 0 : dataset->getPointing().fromXML(tableDoc);
3438 : }
3439 :
3440 0 : entity = dataset->tableEntity["PointingModel"];
3441 0 : if (entity.getEntityId().getId().length() != 0) {
3442 : // Which file must we read ?
3443 0 : string tablename = xmlDirectory + "/PointingModel.xml";
3444 :
3445 : // Determine the file size
3446 0 : ifstream::pos_type size;
3447 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3448 0 : if (tablein.is_open()) {
3449 0 : size = tablein.tellg();
3450 : }
3451 : else {
3452 0 : throw ConversionException("Could not open file " + tablename, "PointingModel");
3453 : }
3454 :
3455 : // Read the file in a string
3456 0 : string tableDoc;
3457 :
3458 0 : tableDoc.reserve(size);
3459 0 : tablein.seekg (0);
3460 0 : int nread = BLOCKSIZE;
3461 0 : while (nread == BLOCKSIZE) {
3462 0 : tablein.read(c, BLOCKSIZE);
3463 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3464 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3465 : }
3466 0 : nread = tablein.gcount();
3467 0 : tableDoc.append(c, nread);
3468 : }
3469 0 : tablein.close();
3470 0 : if (tablein.rdstate() == istream::failbit)
3471 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3472 :
3473 : // And finally parse the XML document to populate the table.
3474 0 : dataset->getPointingModel().fromXML(tableDoc);
3475 : }
3476 :
3477 0 : entity = dataset->tableEntity["Polarization"];
3478 0 : if (entity.getEntityId().getId().length() != 0) {
3479 : // Which file must we read ?
3480 0 : string tablename = xmlDirectory + "/Polarization.xml";
3481 :
3482 : // Determine the file size
3483 0 : ifstream::pos_type size;
3484 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3485 0 : if (tablein.is_open()) {
3486 0 : size = tablein.tellg();
3487 : }
3488 : else {
3489 0 : throw ConversionException("Could not open file " + tablename, "Polarization");
3490 : }
3491 :
3492 : // Read the file in a string
3493 0 : string tableDoc;
3494 :
3495 0 : tableDoc.reserve(size);
3496 0 : tablein.seekg (0);
3497 0 : int nread = BLOCKSIZE;
3498 0 : while (nread == BLOCKSIZE) {
3499 0 : tablein.read(c, BLOCKSIZE);
3500 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3501 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3502 : }
3503 0 : nread = tablein.gcount();
3504 0 : tableDoc.append(c, nread);
3505 : }
3506 0 : tablein.close();
3507 0 : if (tablein.rdstate() == istream::failbit)
3508 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3509 :
3510 : // And finally parse the XML document to populate the table.
3511 0 : dataset->getPolarization().fromXML(tableDoc);
3512 : }
3513 :
3514 0 : entity = dataset->tableEntity["Processor"];
3515 0 : if (entity.getEntityId().getId().length() != 0) {
3516 : // Which file must we read ?
3517 0 : string tablename = xmlDirectory + "/Processor.xml";
3518 :
3519 : // Determine the file size
3520 0 : ifstream::pos_type size;
3521 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3522 0 : if (tablein.is_open()) {
3523 0 : size = tablein.tellg();
3524 : }
3525 : else {
3526 0 : throw ConversionException("Could not open file " + tablename, "Processor");
3527 : }
3528 :
3529 : // Read the file in a string
3530 0 : string tableDoc;
3531 :
3532 0 : tableDoc.reserve(size);
3533 0 : tablein.seekg (0);
3534 0 : int nread = BLOCKSIZE;
3535 0 : while (nread == BLOCKSIZE) {
3536 0 : tablein.read(c, BLOCKSIZE);
3537 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3538 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3539 : }
3540 0 : nread = tablein.gcount();
3541 0 : tableDoc.append(c, nread);
3542 : }
3543 0 : tablein.close();
3544 0 : if (tablein.rdstate() == istream::failbit)
3545 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3546 :
3547 : // And finally parse the XML document to populate the table.
3548 0 : dataset->getProcessor().fromXML(tableDoc);
3549 : }
3550 :
3551 0 : entity = dataset->tableEntity["Pulsar"];
3552 0 : if (entity.getEntityId().getId().length() != 0) {
3553 : // Which file must we read ?
3554 0 : string tablename = xmlDirectory + "/Pulsar.xml";
3555 :
3556 : // Determine the file size
3557 0 : ifstream::pos_type size;
3558 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3559 0 : if (tablein.is_open()) {
3560 0 : size = tablein.tellg();
3561 : }
3562 : else {
3563 0 : throw ConversionException("Could not open file " + tablename, "Pulsar");
3564 : }
3565 :
3566 : // Read the file in a string
3567 0 : string tableDoc;
3568 :
3569 0 : tableDoc.reserve(size);
3570 0 : tablein.seekg (0);
3571 0 : int nread = BLOCKSIZE;
3572 0 : while (nread == BLOCKSIZE) {
3573 0 : tablein.read(c, BLOCKSIZE);
3574 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3575 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3576 : }
3577 0 : nread = tablein.gcount();
3578 0 : tableDoc.append(c, nread);
3579 : }
3580 0 : tablein.close();
3581 0 : if (tablein.rdstate() == istream::failbit)
3582 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3583 :
3584 : // And finally parse the XML document to populate the table.
3585 0 : dataset->getPulsar().fromXML(tableDoc);
3586 : }
3587 :
3588 0 : entity = dataset->tableEntity["Receiver"];
3589 0 : if (entity.getEntityId().getId().length() != 0) {
3590 : // Which file must we read ?
3591 0 : string tablename = xmlDirectory + "/Receiver.xml";
3592 :
3593 : // Determine the file size
3594 0 : ifstream::pos_type size;
3595 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3596 0 : if (tablein.is_open()) {
3597 0 : size = tablein.tellg();
3598 : }
3599 : else {
3600 0 : throw ConversionException("Could not open file " + tablename, "Receiver");
3601 : }
3602 :
3603 : // Read the file in a string
3604 0 : string tableDoc;
3605 :
3606 0 : tableDoc.reserve(size);
3607 0 : tablein.seekg (0);
3608 0 : int nread = BLOCKSIZE;
3609 0 : while (nread == BLOCKSIZE) {
3610 0 : tablein.read(c, BLOCKSIZE);
3611 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3612 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3613 : }
3614 0 : nread = tablein.gcount();
3615 0 : tableDoc.append(c, nread);
3616 : }
3617 0 : tablein.close();
3618 0 : if (tablein.rdstate() == istream::failbit)
3619 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3620 :
3621 : // And finally parse the XML document to populate the table.
3622 0 : dataset->getReceiver().fromXML(tableDoc);
3623 : }
3624 :
3625 0 : entity = dataset->tableEntity["SBSummary"];
3626 0 : if (entity.getEntityId().getId().length() != 0) {
3627 : // Which file must we read ?
3628 0 : string tablename = xmlDirectory + "/SBSummary.xml";
3629 :
3630 : // Determine the file size
3631 0 : ifstream::pos_type size;
3632 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3633 0 : if (tablein.is_open()) {
3634 0 : size = tablein.tellg();
3635 : }
3636 : else {
3637 0 : throw ConversionException("Could not open file " + tablename, "SBSummary");
3638 : }
3639 :
3640 : // Read the file in a string
3641 0 : string tableDoc;
3642 :
3643 0 : tableDoc.reserve(size);
3644 0 : tablein.seekg (0);
3645 0 : int nread = BLOCKSIZE;
3646 0 : while (nread == BLOCKSIZE) {
3647 0 : tablein.read(c, BLOCKSIZE);
3648 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3649 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3650 : }
3651 0 : nread = tablein.gcount();
3652 0 : tableDoc.append(c, nread);
3653 : }
3654 0 : tablein.close();
3655 0 : if (tablein.rdstate() == istream::failbit)
3656 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3657 :
3658 : // And finally parse the XML document to populate the table.
3659 0 : dataset->getSBSummary().fromXML(tableDoc);
3660 : }
3661 :
3662 0 : entity = dataset->tableEntity["Scale"];
3663 0 : if (entity.getEntityId().getId().length() != 0) {
3664 : // Which file must we read ?
3665 0 : string tablename = xmlDirectory + "/Scale.xml";
3666 :
3667 : // Determine the file size
3668 0 : ifstream::pos_type size;
3669 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3670 0 : if (tablein.is_open()) {
3671 0 : size = tablein.tellg();
3672 : }
3673 : else {
3674 0 : throw ConversionException("Could not open file " + tablename, "Scale");
3675 : }
3676 :
3677 : // Read the file in a string
3678 0 : string tableDoc;
3679 :
3680 0 : tableDoc.reserve(size);
3681 0 : tablein.seekg (0);
3682 0 : int nread = BLOCKSIZE;
3683 0 : while (nread == BLOCKSIZE) {
3684 0 : tablein.read(c, BLOCKSIZE);
3685 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3686 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3687 : }
3688 0 : nread = tablein.gcount();
3689 0 : tableDoc.append(c, nread);
3690 : }
3691 0 : tablein.close();
3692 0 : if (tablein.rdstate() == istream::failbit)
3693 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3694 :
3695 : // And finally parse the XML document to populate the table.
3696 0 : dataset->getScale().fromXML(tableDoc);
3697 : }
3698 :
3699 0 : entity = dataset->tableEntity["Scan"];
3700 0 : if (entity.getEntityId().getId().length() != 0) {
3701 : // Which file must we read ?
3702 0 : string tablename = xmlDirectory + "/Scan.xml";
3703 :
3704 : // Determine the file size
3705 0 : ifstream::pos_type size;
3706 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3707 0 : if (tablein.is_open()) {
3708 0 : size = tablein.tellg();
3709 : }
3710 : else {
3711 0 : throw ConversionException("Could not open file " + tablename, "Scan");
3712 : }
3713 :
3714 : // Read the file in a string
3715 0 : string tableDoc;
3716 :
3717 0 : tableDoc.reserve(size);
3718 0 : tablein.seekg (0);
3719 0 : int nread = BLOCKSIZE;
3720 0 : while (nread == BLOCKSIZE) {
3721 0 : tablein.read(c, BLOCKSIZE);
3722 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3723 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3724 : }
3725 0 : nread = tablein.gcount();
3726 0 : tableDoc.append(c, nread);
3727 : }
3728 0 : tablein.close();
3729 0 : if (tablein.rdstate() == istream::failbit)
3730 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3731 :
3732 : // And finally parse the XML document to populate the table.
3733 0 : dataset->getScan().fromXML(tableDoc);
3734 : }
3735 :
3736 0 : entity = dataset->tableEntity["Seeing"];
3737 0 : if (entity.getEntityId().getId().length() != 0) {
3738 : // Which file must we read ?
3739 0 : string tablename = xmlDirectory + "/Seeing.xml";
3740 :
3741 : // Determine the file size
3742 0 : ifstream::pos_type size;
3743 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3744 0 : if (tablein.is_open()) {
3745 0 : size = tablein.tellg();
3746 : }
3747 : else {
3748 0 : throw ConversionException("Could not open file " + tablename, "Seeing");
3749 : }
3750 :
3751 : // Read the file in a string
3752 0 : string tableDoc;
3753 :
3754 0 : tableDoc.reserve(size);
3755 0 : tablein.seekg (0);
3756 0 : int nread = BLOCKSIZE;
3757 0 : while (nread == BLOCKSIZE) {
3758 0 : tablein.read(c, BLOCKSIZE);
3759 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3760 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3761 : }
3762 0 : nread = tablein.gcount();
3763 0 : tableDoc.append(c, nread);
3764 : }
3765 0 : tablein.close();
3766 0 : if (tablein.rdstate() == istream::failbit)
3767 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3768 :
3769 : // And finally parse the XML document to populate the table.
3770 0 : dataset->getSeeing().fromXML(tableDoc);
3771 : }
3772 :
3773 0 : entity = dataset->tableEntity["Source"];
3774 0 : if (entity.getEntityId().getId().length() != 0) {
3775 : // Which file must we read ?
3776 0 : string tablename = xmlDirectory + "/Source.xml";
3777 :
3778 : // Determine the file size
3779 0 : ifstream::pos_type size;
3780 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3781 0 : if (tablein.is_open()) {
3782 0 : size = tablein.tellg();
3783 : }
3784 : else {
3785 0 : throw ConversionException("Could not open file " + tablename, "Source");
3786 : }
3787 :
3788 : // Read the file in a string
3789 0 : string tableDoc;
3790 :
3791 0 : tableDoc.reserve(size);
3792 0 : tablein.seekg (0);
3793 0 : int nread = BLOCKSIZE;
3794 0 : while (nread == BLOCKSIZE) {
3795 0 : tablein.read(c, BLOCKSIZE);
3796 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3797 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3798 : }
3799 0 : nread = tablein.gcount();
3800 0 : tableDoc.append(c, nread);
3801 : }
3802 0 : tablein.close();
3803 0 : if (tablein.rdstate() == istream::failbit)
3804 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3805 :
3806 : // And finally parse the XML document to populate the table.
3807 0 : dataset->getSource().fromXML(tableDoc);
3808 : }
3809 :
3810 0 : entity = dataset->tableEntity["SpectralWindow"];
3811 0 : if (entity.getEntityId().getId().length() != 0) {
3812 : // Which file must we read ?
3813 0 : string tablename = xmlDirectory + "/SpectralWindow.xml";
3814 :
3815 : // Determine the file size
3816 0 : ifstream::pos_type size;
3817 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3818 0 : if (tablein.is_open()) {
3819 0 : size = tablein.tellg();
3820 : }
3821 : else {
3822 0 : throw ConversionException("Could not open file " + tablename, "SpectralWindow");
3823 : }
3824 :
3825 : // Read the file in a string
3826 0 : string tableDoc;
3827 :
3828 0 : tableDoc.reserve(size);
3829 0 : tablein.seekg (0);
3830 0 : int nread = BLOCKSIZE;
3831 0 : while (nread == BLOCKSIZE) {
3832 0 : tablein.read(c, BLOCKSIZE);
3833 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3834 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3835 : }
3836 0 : nread = tablein.gcount();
3837 0 : tableDoc.append(c, nread);
3838 : }
3839 0 : tablein.close();
3840 0 : if (tablein.rdstate() == istream::failbit)
3841 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3842 :
3843 : // And finally parse the XML document to populate the table.
3844 0 : dataset->getSpectralWindow().fromXML(tableDoc);
3845 : }
3846 :
3847 0 : entity = dataset->tableEntity["SquareLawDetector"];
3848 0 : if (entity.getEntityId().getId().length() != 0) {
3849 : // Which file must we read ?
3850 0 : string tablename = xmlDirectory + "/SquareLawDetector.xml";
3851 :
3852 : // Determine the file size
3853 0 : ifstream::pos_type size;
3854 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3855 0 : if (tablein.is_open()) {
3856 0 : size = tablein.tellg();
3857 : }
3858 : else {
3859 0 : throw ConversionException("Could not open file " + tablename, "SquareLawDetector");
3860 : }
3861 :
3862 : // Read the file in a string
3863 0 : string tableDoc;
3864 :
3865 0 : tableDoc.reserve(size);
3866 0 : tablein.seekg (0);
3867 0 : int nread = BLOCKSIZE;
3868 0 : while (nread == BLOCKSIZE) {
3869 0 : tablein.read(c, BLOCKSIZE);
3870 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3871 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3872 : }
3873 0 : nread = tablein.gcount();
3874 0 : tableDoc.append(c, nread);
3875 : }
3876 0 : tablein.close();
3877 0 : if (tablein.rdstate() == istream::failbit)
3878 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3879 :
3880 : // And finally parse the XML document to populate the table.
3881 0 : dataset->getSquareLawDetector().fromXML(tableDoc);
3882 : }
3883 :
3884 0 : entity = dataset->tableEntity["State"];
3885 0 : if (entity.getEntityId().getId().length() != 0) {
3886 : // Which file must we read ?
3887 0 : string tablename = xmlDirectory + "/State.xml";
3888 :
3889 : // Determine the file size
3890 0 : ifstream::pos_type size;
3891 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3892 0 : if (tablein.is_open()) {
3893 0 : size = tablein.tellg();
3894 : }
3895 : else {
3896 0 : throw ConversionException("Could not open file " + tablename, "State");
3897 : }
3898 :
3899 : // Read the file in a string
3900 0 : string tableDoc;
3901 :
3902 0 : tableDoc.reserve(size);
3903 0 : tablein.seekg (0);
3904 0 : int nread = BLOCKSIZE;
3905 0 : while (nread == BLOCKSIZE) {
3906 0 : tablein.read(c, BLOCKSIZE);
3907 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3908 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3909 : }
3910 0 : nread = tablein.gcount();
3911 0 : tableDoc.append(c, nread);
3912 : }
3913 0 : tablein.close();
3914 0 : if (tablein.rdstate() == istream::failbit)
3915 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3916 :
3917 : // And finally parse the XML document to populate the table.
3918 0 : dataset->getState().fromXML(tableDoc);
3919 : }
3920 :
3921 0 : entity = dataset->tableEntity["Station"];
3922 0 : if (entity.getEntityId().getId().length() != 0) {
3923 : // Which file must we read ?
3924 0 : string tablename = xmlDirectory + "/Station.xml";
3925 :
3926 : // Determine the file size
3927 0 : ifstream::pos_type size;
3928 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3929 0 : if (tablein.is_open()) {
3930 0 : size = tablein.tellg();
3931 : }
3932 : else {
3933 0 : throw ConversionException("Could not open file " + tablename, "Station");
3934 : }
3935 :
3936 : // Read the file in a string
3937 0 : string tableDoc;
3938 :
3939 0 : tableDoc.reserve(size);
3940 0 : tablein.seekg (0);
3941 0 : int nread = BLOCKSIZE;
3942 0 : while (nread == BLOCKSIZE) {
3943 0 : tablein.read(c, BLOCKSIZE);
3944 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3945 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3946 : }
3947 0 : nread = tablein.gcount();
3948 0 : tableDoc.append(c, nread);
3949 : }
3950 0 : tablein.close();
3951 0 : if (tablein.rdstate() == istream::failbit)
3952 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3953 :
3954 : // And finally parse the XML document to populate the table.
3955 0 : dataset->getStation().fromXML(tableDoc);
3956 : }
3957 :
3958 0 : entity = dataset->tableEntity["Subscan"];
3959 0 : if (entity.getEntityId().getId().length() != 0) {
3960 : // Which file must we read ?
3961 0 : string tablename = xmlDirectory + "/Subscan.xml";
3962 :
3963 : // Determine the file size
3964 0 : ifstream::pos_type size;
3965 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
3966 0 : if (tablein.is_open()) {
3967 0 : size = tablein.tellg();
3968 : }
3969 : else {
3970 0 : throw ConversionException("Could not open file " + tablename, "Subscan");
3971 : }
3972 :
3973 : // Read the file in a string
3974 0 : string tableDoc;
3975 :
3976 0 : tableDoc.reserve(size);
3977 0 : tablein.seekg (0);
3978 0 : int nread = BLOCKSIZE;
3979 0 : while (nread == BLOCKSIZE) {
3980 0 : tablein.read(c, BLOCKSIZE);
3981 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
3982 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
3983 : }
3984 0 : nread = tablein.gcount();
3985 0 : tableDoc.append(c, nread);
3986 : }
3987 0 : tablein.close();
3988 0 : if (tablein.rdstate() == istream::failbit)
3989 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
3990 :
3991 : // And finally parse the XML document to populate the table.
3992 0 : dataset->getSubscan().fromXML(tableDoc);
3993 : }
3994 :
3995 0 : entity = dataset->tableEntity["SwitchCycle"];
3996 0 : if (entity.getEntityId().getId().length() != 0) {
3997 : // Which file must we read ?
3998 0 : string tablename = xmlDirectory + "/SwitchCycle.xml";
3999 :
4000 : // Determine the file size
4001 0 : ifstream::pos_type size;
4002 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
4003 0 : if (tablein.is_open()) {
4004 0 : size = tablein.tellg();
4005 : }
4006 : else {
4007 0 : throw ConversionException("Could not open file " + tablename, "SwitchCycle");
4008 : }
4009 :
4010 : // Read the file in a string
4011 0 : string tableDoc;
4012 :
4013 0 : tableDoc.reserve(size);
4014 0 : tablein.seekg (0);
4015 0 : int nread = BLOCKSIZE;
4016 0 : while (nread == BLOCKSIZE) {
4017 0 : tablein.read(c, BLOCKSIZE);
4018 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
4019 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
4020 : }
4021 0 : nread = tablein.gcount();
4022 0 : tableDoc.append(c, nread);
4023 : }
4024 0 : tablein.close();
4025 0 : if (tablein.rdstate() == istream::failbit)
4026 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
4027 :
4028 : // And finally parse the XML document to populate the table.
4029 0 : dataset->getSwitchCycle().fromXML(tableDoc);
4030 : }
4031 :
4032 0 : entity = dataset->tableEntity["SysCal"];
4033 0 : if (entity.getEntityId().getId().length() != 0) {
4034 : // Which file must we read ?
4035 0 : string tablename = xmlDirectory + "/SysCal.xml";
4036 :
4037 : // Determine the file size
4038 0 : ifstream::pos_type size;
4039 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
4040 0 : if (tablein.is_open()) {
4041 0 : size = tablein.tellg();
4042 : }
4043 : else {
4044 0 : throw ConversionException("Could not open file " + tablename, "SysCal");
4045 : }
4046 :
4047 : // Read the file in a string
4048 0 : string tableDoc;
4049 :
4050 0 : tableDoc.reserve(size);
4051 0 : tablein.seekg (0);
4052 0 : int nread = BLOCKSIZE;
4053 0 : while (nread == BLOCKSIZE) {
4054 0 : tablein.read(c, BLOCKSIZE);
4055 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
4056 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
4057 : }
4058 0 : nread = tablein.gcount();
4059 0 : tableDoc.append(c, nread);
4060 : }
4061 0 : tablein.close();
4062 0 : if (tablein.rdstate() == istream::failbit)
4063 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
4064 :
4065 : // And finally parse the XML document to populate the table.
4066 0 : dataset->getSysCal().fromXML(tableDoc);
4067 : }
4068 :
4069 0 : entity = dataset->tableEntity["SysPower"];
4070 0 : if (entity.getEntityId().getId().length() != 0) {
4071 : // Which file must we read ?
4072 0 : string tablename = xmlDirectory + "/SysPower.xml";
4073 :
4074 : // Determine the file size
4075 0 : ifstream::pos_type size;
4076 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
4077 0 : if (tablein.is_open()) {
4078 0 : size = tablein.tellg();
4079 : }
4080 : else {
4081 0 : throw ConversionException("Could not open file " + tablename, "SysPower");
4082 : }
4083 :
4084 : // Read the file in a string
4085 0 : string tableDoc;
4086 :
4087 0 : tableDoc.reserve(size);
4088 0 : tablein.seekg (0);
4089 0 : int nread = BLOCKSIZE;
4090 0 : while (nread == BLOCKSIZE) {
4091 0 : tablein.read(c, BLOCKSIZE);
4092 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
4093 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
4094 : }
4095 0 : nread = tablein.gcount();
4096 0 : tableDoc.append(c, nread);
4097 : }
4098 0 : tablein.close();
4099 0 : if (tablein.rdstate() == istream::failbit)
4100 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
4101 :
4102 : // And finally parse the XML document to populate the table.
4103 0 : dataset->getSysPower().fromXML(tableDoc);
4104 : }
4105 :
4106 0 : entity = dataset->tableEntity["TotalPower"];
4107 0 : if (entity.getEntityId().getId().length() != 0) {
4108 : // Which file must we read ?
4109 0 : string tablename = xmlDirectory + "/TotalPower.xml";
4110 :
4111 : // Determine the file size
4112 0 : ifstream::pos_type size;
4113 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
4114 0 : if (tablein.is_open()) {
4115 0 : size = tablein.tellg();
4116 : }
4117 : else {
4118 0 : throw ConversionException("Could not open file " + tablename, "TotalPower");
4119 : }
4120 :
4121 : // Read the file in a string
4122 0 : string tableDoc;
4123 :
4124 0 : tableDoc.reserve(size);
4125 0 : tablein.seekg (0);
4126 0 : int nread = BLOCKSIZE;
4127 0 : while (nread == BLOCKSIZE) {
4128 0 : tablein.read(c, BLOCKSIZE);
4129 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
4130 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
4131 : }
4132 0 : nread = tablein.gcount();
4133 0 : tableDoc.append(c, nread);
4134 : }
4135 0 : tablein.close();
4136 0 : if (tablein.rdstate() == istream::failbit)
4137 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
4138 :
4139 : // And finally parse the XML document to populate the table.
4140 0 : dataset->getTotalPower().fromXML(tableDoc);
4141 : }
4142 :
4143 0 : entity = dataset->tableEntity["VLAWVR"];
4144 0 : if (entity.getEntityId().getId().length() != 0) {
4145 : // Which file must we read ?
4146 0 : string tablename = xmlDirectory + "/VLAWVR.xml";
4147 :
4148 : // Determine the file size
4149 0 : ifstream::pos_type size;
4150 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
4151 0 : if (tablein.is_open()) {
4152 0 : size = tablein.tellg();
4153 : }
4154 : else {
4155 0 : throw ConversionException("Could not open file " + tablename, "VLAWVR");
4156 : }
4157 :
4158 : // Read the file in a string
4159 0 : string tableDoc;
4160 :
4161 0 : tableDoc.reserve(size);
4162 0 : tablein.seekg (0);
4163 0 : int nread = BLOCKSIZE;
4164 0 : while (nread == BLOCKSIZE) {
4165 0 : tablein.read(c, BLOCKSIZE);
4166 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
4167 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
4168 : }
4169 0 : nread = tablein.gcount();
4170 0 : tableDoc.append(c, nread);
4171 : }
4172 0 : tablein.close();
4173 0 : if (tablein.rdstate() == istream::failbit)
4174 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
4175 :
4176 : // And finally parse the XML document to populate the table.
4177 0 : dataset->getVLAWVR().fromXML(tableDoc);
4178 : }
4179 :
4180 0 : entity = dataset->tableEntity["WVMCal"];
4181 0 : if (entity.getEntityId().getId().length() != 0) {
4182 : // Which file must we read ?
4183 0 : string tablename = xmlDirectory + "/WVMCal.xml";
4184 :
4185 : // Determine the file size
4186 0 : ifstream::pos_type size;
4187 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
4188 0 : if (tablein.is_open()) {
4189 0 : size = tablein.tellg();
4190 : }
4191 : else {
4192 0 : throw ConversionException("Could not open file " + tablename, "WVMCal");
4193 : }
4194 :
4195 : // Read the file in a string
4196 0 : string tableDoc;
4197 :
4198 0 : tableDoc.reserve(size);
4199 0 : tablein.seekg (0);
4200 0 : int nread = BLOCKSIZE;
4201 0 : while (nread == BLOCKSIZE) {
4202 0 : tablein.read(c, BLOCKSIZE);
4203 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
4204 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
4205 : }
4206 0 : nread = tablein.gcount();
4207 0 : tableDoc.append(c, nread);
4208 : }
4209 0 : tablein.close();
4210 0 : if (tablein.rdstate() == istream::failbit)
4211 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
4212 :
4213 : // And finally parse the XML document to populate the table.
4214 0 : dataset->getWVMCal().fromXML(tableDoc);
4215 : }
4216 :
4217 0 : entity = dataset->tableEntity["Weather"];
4218 0 : if (entity.getEntityId().getId().length() != 0) {
4219 : // Which file must we read ?
4220 0 : string tablename = xmlDirectory + "/Weather.xml";
4221 :
4222 : // Determine the file size
4223 0 : ifstream::pos_type size;
4224 0 : ifstream tablein (tablename.c_str() , ios::in|ios::binary|ios::ate);
4225 0 : if (tablein.is_open()) {
4226 0 : size = tablein.tellg();
4227 : }
4228 : else {
4229 0 : throw ConversionException("Could not open file " + tablename, "Weather");
4230 : }
4231 :
4232 : // Read the file in a string
4233 0 : string tableDoc;
4234 :
4235 0 : tableDoc.reserve(size);
4236 0 : tablein.seekg (0);
4237 0 : int nread = BLOCKSIZE;
4238 0 : while (nread == BLOCKSIZE) {
4239 0 : tablein.read(c, BLOCKSIZE);
4240 0 : if (tablein.rdstate() == istream::failbit || tablein.rdstate() == istream::badbit) {
4241 0 : throw ConversionException("Error reading file " + tablename,"ASDM");
4242 : }
4243 0 : nread = tablein.gcount();
4244 0 : tableDoc.append(c, nread);
4245 : }
4246 0 : tablein.close();
4247 0 : if (tablein.rdstate() == istream::failbit)
4248 0 : throw ConversionException("Could not close file " + tablename,"ASDM");
4249 :
4250 : // And finally parse the XML document to populate the table.
4251 0 : dataset->getWeather().fromXML(tableDoc);
4252 : }
4253 :
4254 0 : return dataset;
4255 : }
4256 :
4257 0 : string ASDM::toMIME() {
4258 : // To be implemented
4259 0 : return "";
4260 : ;
4261 : }
4262 :
4263 0 : void ASDM::setFromMIME(const string & /* mimeMsg */) {
4264 : // To be implemented
4265 : ;
4266 0 : }
4267 :
4268 :
4269 13 : void ASDM::toFile(string directory) {
4270 13 : if (!directoryExists(directory.c_str()) &&
4271 0 : !createPath(directory.c_str())) {
4272 0 : throw ConversionException("Could not create directory " , directory);
4273 : }
4274 :
4275 : // Firstly send the container to its file.
4276 13 : if (fileAsBin) {
4277 : // write the bin serialized
4278 0 : string fileName = directory + "/ASDM.bin";
4279 0 : ofstream tableout(fileName.c_str(),ios::out|ios::trunc);
4280 0 : if (tableout.rdstate() == ostream::failbit)
4281 0 : throw ConversionException("Could not open file " + fileName, "ASDM");
4282 0 : tableout << toMIME() << endl;
4283 0 : tableout.close();
4284 0 : if (tableout.rdstate() == ostream::failbit)
4285 0 : throw ConversionException("Could not close file " + fileName, "ASDM");
4286 : }
4287 : else {
4288 : // write the XML
4289 26 : string fileName = directory + "/ASDM.xml";
4290 26 : ofstream tableout(fileName.c_str(),ios::out|ios::trunc);
4291 13 : if (tableout.rdstate() == ostream::failbit)
4292 0 : throw ConversionException("Could not open file " + fileName , "ASDM");
4293 13 : tableout << toXML() << endl;
4294 13 : tableout.close();
4295 13 : if (tableout.rdstate() == ostream::failbit)
4296 0 : throw ConversionException("Could not close file " + fileName, "ASDM");
4297 : }
4298 :
4299 : // Then send each of its table to its own file.
4300 :
4301 13 : if (getMain().size() > 0) {
4302 13 : getMain().toFile(directory);
4303 : }
4304 :
4305 13 : if (getAlmaRadiometer().size() > 0) {
4306 0 : getAlmaRadiometer().toFile(directory);
4307 : }
4308 :
4309 13 : if (getAnnotation().size() > 0) {
4310 0 : getAnnotation().toFile(directory);
4311 : }
4312 :
4313 13 : if (getAntenna().size() > 0) {
4314 13 : getAntenna().toFile(directory);
4315 : }
4316 :
4317 13 : if (getCalAmpli().size() > 0) {
4318 0 : getCalAmpli().toFile(directory);
4319 : }
4320 :
4321 13 : if (getCalAntennaSolutions().size() > 0) {
4322 0 : getCalAntennaSolutions().toFile(directory);
4323 : }
4324 :
4325 13 : if (getCalAppPhase().size() > 0) {
4326 0 : getCalAppPhase().toFile(directory);
4327 : }
4328 :
4329 13 : if (getCalAtmosphere().size() > 0) {
4330 0 : getCalAtmosphere().toFile(directory);
4331 : }
4332 :
4333 13 : if (getCalBandpass().size() > 0) {
4334 0 : getCalBandpass().toFile(directory);
4335 : }
4336 :
4337 13 : if (getCalCurve().size() > 0) {
4338 0 : getCalCurve().toFile(directory);
4339 : }
4340 :
4341 13 : if (getCalData().size() > 0) {
4342 0 : getCalData().toFile(directory);
4343 : }
4344 :
4345 13 : if (getCalDelay().size() > 0) {
4346 0 : getCalDelay().toFile(directory);
4347 : }
4348 :
4349 13 : if (getCalDevice().size() > 0) {
4350 0 : getCalDevice().toFile(directory);
4351 : }
4352 :
4353 13 : if (getCalFlux().size() > 0) {
4354 0 : getCalFlux().toFile(directory);
4355 : }
4356 :
4357 13 : if (getCalFocus().size() > 0) {
4358 0 : getCalFocus().toFile(directory);
4359 : }
4360 :
4361 13 : if (getCalFocusModel().size() > 0) {
4362 0 : getCalFocusModel().toFile(directory);
4363 : }
4364 :
4365 13 : if (getCalGain().size() > 0) {
4366 0 : getCalGain().toFile(directory);
4367 : }
4368 :
4369 13 : if (getCalHolography().size() > 0) {
4370 0 : getCalHolography().toFile(directory);
4371 : }
4372 :
4373 13 : if (getCalPhase().size() > 0) {
4374 0 : getCalPhase().toFile(directory);
4375 : }
4376 :
4377 13 : if (getCalPointing().size() > 0) {
4378 0 : getCalPointing().toFile(directory);
4379 : }
4380 :
4381 13 : if (getCalPointingModel().size() > 0) {
4382 0 : getCalPointingModel().toFile(directory);
4383 : }
4384 :
4385 13 : if (getCalPosition().size() > 0) {
4386 0 : getCalPosition().toFile(directory);
4387 : }
4388 :
4389 13 : if (getCalPrimaryBeam().size() > 0) {
4390 0 : getCalPrimaryBeam().toFile(directory);
4391 : }
4392 :
4393 13 : if (getCalReduction().size() > 0) {
4394 0 : getCalReduction().toFile(directory);
4395 : }
4396 :
4397 13 : if (getCalSeeing().size() > 0) {
4398 0 : getCalSeeing().toFile(directory);
4399 : }
4400 :
4401 13 : if (getCalWVR().size() > 0) {
4402 0 : getCalWVR().toFile(directory);
4403 : }
4404 :
4405 13 : if (getConfigDescription().size() > 0) {
4406 13 : getConfigDescription().toFile(directory);
4407 : }
4408 :
4409 13 : if (getCorrelatorMode().size() > 0) {
4410 13 : getCorrelatorMode().toFile(directory);
4411 : }
4412 :
4413 13 : if (getDataDescription().size() > 0) {
4414 13 : getDataDescription().toFile(directory);
4415 : }
4416 :
4417 13 : if (getDelayModel().size() > 0) {
4418 0 : getDelayModel().toFile(directory);
4419 : }
4420 :
4421 13 : if (getDelayModelFixedParameters().size() > 0) {
4422 0 : getDelayModelFixedParameters().toFile(directory);
4423 : }
4424 :
4425 13 : if (getDelayModelVariableParameters().size() > 0) {
4426 0 : getDelayModelVariableParameters().toFile(directory);
4427 : }
4428 :
4429 13 : if (getDoppler().size() > 0) {
4430 0 : getDoppler().toFile(directory);
4431 : }
4432 :
4433 13 : if (getEphemeris().size() > 0) {
4434 0 : getEphemeris().toFile(directory);
4435 : }
4436 :
4437 13 : if (getExecBlock().size() > 0) {
4438 13 : getExecBlock().toFile(directory);
4439 : }
4440 :
4441 13 : if (getFeed().size() > 0) {
4442 13 : getFeed().toFile(directory);
4443 : }
4444 :
4445 13 : if (getField().size() > 0) {
4446 13 : getField().toFile(directory);
4447 : }
4448 :
4449 13 : if (getFlag().size() > 0) {
4450 0 : getFlag().toFile(directory);
4451 : }
4452 :
4453 13 : if (getFlagCmd().size() > 0) {
4454 0 : getFlagCmd().toFile(directory);
4455 : }
4456 :
4457 13 : if (getFocus().size() > 0) {
4458 0 : getFocus().toFile(directory);
4459 : }
4460 :
4461 13 : if (getFocusModel().size() > 0) {
4462 0 : getFocusModel().toFile(directory);
4463 : }
4464 :
4465 13 : if (getFreqOffset().size() > 0) {
4466 0 : getFreqOffset().toFile(directory);
4467 : }
4468 :
4469 13 : if (getGainTracking().size() > 0) {
4470 0 : getGainTracking().toFile(directory);
4471 : }
4472 :
4473 13 : if (getHistory().size() > 0) {
4474 0 : getHistory().toFile(directory);
4475 : }
4476 :
4477 13 : if (getHolography().size() > 0) {
4478 0 : getHolography().toFile(directory);
4479 : }
4480 :
4481 13 : if (getObservation().size() > 0) {
4482 0 : getObservation().toFile(directory);
4483 : }
4484 :
4485 13 : if (getPointing().size() > 0) {
4486 9 : getPointing().toFile(directory);
4487 : }
4488 :
4489 13 : if (getPointingModel().size() > 0) {
4490 13 : getPointingModel().toFile(directory);
4491 : }
4492 :
4493 13 : if (getPolarization().size() > 0) {
4494 13 : getPolarization().toFile(directory);
4495 : }
4496 :
4497 13 : if (getProcessor().size() > 0) {
4498 13 : getProcessor().toFile(directory);
4499 : }
4500 :
4501 13 : if (getPulsar().size() > 0) {
4502 0 : getPulsar().toFile(directory);
4503 : }
4504 :
4505 13 : if (getReceiver().size() > 0) {
4506 13 : getReceiver().toFile(directory);
4507 : }
4508 :
4509 13 : if (getSBSummary().size() > 0) {
4510 13 : getSBSummary().toFile(directory);
4511 : }
4512 :
4513 13 : if (getScale().size() > 0) {
4514 0 : getScale().toFile(directory);
4515 : }
4516 :
4517 13 : if (getScan().size() > 0) {
4518 13 : getScan().toFile(directory);
4519 : }
4520 :
4521 13 : if (getSeeing().size() > 0) {
4522 0 : getSeeing().toFile(directory);
4523 : }
4524 :
4525 13 : if (getSource().size() > 0) {
4526 13 : getSource().toFile(directory);
4527 : }
4528 :
4529 13 : if (getSpectralWindow().size() > 0) {
4530 13 : getSpectralWindow().toFile(directory);
4531 : }
4532 :
4533 13 : if (getSquareLawDetector().size() > 0) {
4534 0 : getSquareLawDetector().toFile(directory);
4535 : }
4536 :
4537 13 : if (getState().size() > 0) {
4538 13 : getState().toFile(directory);
4539 : }
4540 :
4541 13 : if (getStation().size() > 0) {
4542 13 : getStation().toFile(directory);
4543 : }
4544 :
4545 13 : if (getSubscan().size() > 0) {
4546 13 : getSubscan().toFile(directory);
4547 : }
4548 :
4549 13 : if (getSwitchCycle().size() > 0) {
4550 13 : getSwitchCycle().toFile(directory);
4551 : }
4552 :
4553 13 : if (getSysCal().size() > 0) {
4554 13 : getSysCal().toFile(directory);
4555 : }
4556 :
4557 13 : if (getSysPower().size() > 0) {
4558 0 : getSysPower().toFile(directory);
4559 : }
4560 :
4561 13 : if (getTotalPower().size() > 0) {
4562 0 : getTotalPower().toFile(directory);
4563 : }
4564 :
4565 13 : if (getVLAWVR().size() > 0) {
4566 0 : getVLAWVR().toFile(directory);
4567 : }
4568 :
4569 13 : if (getWVMCal().size() > 0) {
4570 0 : getWVMCal().toFile(directory);
4571 : }
4572 :
4573 13 : if (getWeather().size() > 0) {
4574 0 : getWeather().toFile(directory);
4575 : }
4576 :
4577 13 : }
4578 :
4579 :
4580 :
4581 :
4582 0 : void ASDM::setFromFile(string directory, bool loadTablesOnDemand) {
4583 0 : this->setFromFile(directory, ASDMParseOptions().loadTablesOnDemand(loadTablesOnDemand));
4584 0 : }
4585 :
4586 83 : void ASDM::setFromFile(string directory, const ASDMParseOptions& parse) {
4587 :
4588 83 : this->loadTablesOnDemand_ = parse.loadTablesOnDemand_;
4589 83 : this->checkRowUniqueness_ = parse.checkRowUniqueness_;
4590 83 : this->directory_ = directory;
4591 83 : string fileName;
4592 83 : if (fileAsBin) {
4593 0 : fileName = directory + "/ASDM.bin";
4594 : // Determine the file size.
4595 0 : ifstream::pos_type size;
4596 0 : ifstream theFile(fileName.c_str(), ios::in|ios::binary|ios::ate);
4597 :
4598 0 : if (theFile.is_open()) {
4599 0 : size = theFile.tellg();
4600 : }
4601 : else {
4602 0 : throw ConversionException("Could not open file " + fileName, "ASDM");
4603 : }
4604 :
4605 : // Re position to the beginning.
4606 0 : theFile.seekg(0);
4607 :
4608 : // Read in a stringstream.
4609 0 : stringstream ss;
4610 0 : ss << theFile.rdbuf();
4611 :
4612 0 : if (theFile.rdstate() == istream::failbit || theFile.rdstate() == istream::badbit) {
4613 0 : throw ConversionException("Error reading file " + fileName,"ASDM");
4614 : }
4615 :
4616 : // And close
4617 0 : theFile.close();
4618 0 : if (theFile.rdstate() == istream::failbit)
4619 0 : throw ConversionException("Could not close file " + fileName,"ASDM");
4620 :
4621 0 : setFromMIME(ss.str());
4622 : }
4623 : else {
4624 83 : fileName = directory + "/ASDM.xml";
4625 166 : string version ;
4626 : ASDMUtils::Origin origin;
4627 :
4628 : try {
4629 166 : version = parse.detectVersion_ ? ASDMUtils::version(directory_) : parse.version_;
4630 83 : origin = parse.detectOrigin_ ? ASDMUtils::origin(ASDMUtils::telescopeNames(directory_)) : parse.origin_;
4631 : }
4632 0 : catch (const ASDMUtilsException &e) {
4633 0 : throw ConversionException ("Caught an exception whose message is '" + e.getMessage() + "'.", "ASDM");
4634 : }
4635 :
4636 83 : if ((version == "UNKNOWN") && (origin == ASDMUtils::UNKNOWN))
4637 0 : throw ConversionException("I cannot read this dataset with version='UNKNOWN' and origin='UNKNOWN'", "ASDM");
4638 :
4639 : // convert leading part of version to an integer (this will work for things like "4.2.1" if necessary)
4640 166 : std::locale loc;
4641 : // require that the first character is a digit
4642 83 : int iVersion = -1;
4643 :
4644 : try {
4645 83 : iVersion = std::isdigit(version[0],loc) ? std::stoi(version) : -1;
4646 0 : } catch (const std::invalid_argument &ia) {
4647 0 : throw ConversionException("Invalid argument converting this version into an integer: '" + version + ". Can not continue.", "ASDM");
4648 0 : } catch (const std::out_of_range &oor) {
4649 0 : throw ConversionException("Integer in this version is out of range: '" + version + ". Can not continue.", "ASDM");
4650 : }
4651 :
4652 83 : if (iVersion < 2) {
4653 0 : throw ConversionException("I cannot read this dataset with version='" + version + "'.", "ASDM");
4654 : }
4655 : // this is the case that we know how to transform, ignore everything else and hope for the best
4656 83 : bool doTransform = (iVersion == 2) && (origin == ASDMUtils::EVLA || origin == ASDMUtils::ALMA);
4657 166 : string xsltPath;
4658 83 : string xmlDoc;
4659 : try {
4660 83 : if (doTransform) {
4661 18 : if (origin == ASDMUtils::EVLA)
4662 13 : xsltPath = ASDMUtils::pathToV2V3EVLAxslTransform();
4663 : else
4664 5 : xsltPath = ASDMUtils::pathToV2V3ALMAxslTransform();
4665 :
4666 18 : if (xsltPath.size() == 0)
4667 0 : throw ConversionException("An XSL transformation must be done on this '" + ((origin==ASDMUtils::EVLA) ? string("EVLA") : string("ALMA")) + "' dataset, but its file , '" + ASDMUtils::nameOfV2V3xslTransform(origin) + "' cannot be found.", "ASDM");
4668 :
4669 18 : xslTransformer.setTransformation(xsltPath);
4670 : //cout << "An XSL transformation will be done on this dataset using '" << xsltPath << "'." << endl;
4671 : }
4672 : else {
4673 : //cout << "No transformation will be applied on this dataset." << endl;
4674 : }
4675 :
4676 83 : xmlDoc = getXSLTransformer()(fileName);
4677 : }
4678 0 : catch (const XSLTransformerException &e) {
4679 0 : throw ConversionException("Caugth an exception whose message is '" + e.getMessage() + "'.", "ASDM");
4680 : }
4681 83 : fromXML(xmlDoc);
4682 : }
4683 :
4684 83 : if (!loadTablesOnDemand_) {
4685 : // Now read and parse all files for the tables whose number of rows appear as
4686 : // non null in the container just built.
4687 0 : Entity entity;
4688 :
4689 0 : entity = tableEntity["Main"];
4690 0 : if (entity.getEntityId().getId().length() != 0) {
4691 0 : getMain().setFromFile(directory_);
4692 : }
4693 :
4694 0 : entity = tableEntity["AlmaRadiometer"];
4695 0 : if (entity.getEntityId().getId().length() != 0) {
4696 0 : getAlmaRadiometer().setFromFile(directory_);
4697 : }
4698 :
4699 0 : entity = tableEntity["Annotation"];
4700 0 : if (entity.getEntityId().getId().length() != 0) {
4701 0 : getAnnotation().setFromFile(directory_);
4702 : }
4703 :
4704 0 : entity = tableEntity["Antenna"];
4705 0 : if (entity.getEntityId().getId().length() != 0) {
4706 0 : getAntenna().setFromFile(directory_);
4707 : }
4708 :
4709 0 : entity = tableEntity["CalAmpli"];
4710 0 : if (entity.getEntityId().getId().length() != 0) {
4711 0 : getCalAmpli().setFromFile(directory_);
4712 : }
4713 :
4714 0 : entity = tableEntity["CalAntennaSolutions"];
4715 0 : if (entity.getEntityId().getId().length() != 0) {
4716 0 : getCalAntennaSolutions().setFromFile(directory_);
4717 : }
4718 :
4719 0 : entity = tableEntity["CalAppPhase"];
4720 0 : if (entity.getEntityId().getId().length() != 0) {
4721 0 : getCalAppPhase().setFromFile(directory_);
4722 : }
4723 :
4724 0 : entity = tableEntity["CalAtmosphere"];
4725 0 : if (entity.getEntityId().getId().length() != 0) {
4726 0 : getCalAtmosphere().setFromFile(directory_);
4727 : }
4728 :
4729 0 : entity = tableEntity["CalBandpass"];
4730 0 : if (entity.getEntityId().getId().length() != 0) {
4731 0 : getCalBandpass().setFromFile(directory_);
4732 : }
4733 :
4734 0 : entity = tableEntity["CalCurve"];
4735 0 : if (entity.getEntityId().getId().length() != 0) {
4736 0 : getCalCurve().setFromFile(directory_);
4737 : }
4738 :
4739 0 : entity = tableEntity["CalData"];
4740 0 : if (entity.getEntityId().getId().length() != 0) {
4741 0 : getCalData().setFromFile(directory_);
4742 : }
4743 :
4744 0 : entity = tableEntity["CalDelay"];
4745 0 : if (entity.getEntityId().getId().length() != 0) {
4746 0 : getCalDelay().setFromFile(directory_);
4747 : }
4748 :
4749 0 : entity = tableEntity["CalDevice"];
4750 0 : if (entity.getEntityId().getId().length() != 0) {
4751 0 : getCalDevice().setFromFile(directory_);
4752 : }
4753 :
4754 0 : entity = tableEntity["CalFlux"];
4755 0 : if (entity.getEntityId().getId().length() != 0) {
4756 0 : getCalFlux().setFromFile(directory_);
4757 : }
4758 :
4759 0 : entity = tableEntity["CalFocus"];
4760 0 : if (entity.getEntityId().getId().length() != 0) {
4761 0 : getCalFocus().setFromFile(directory_);
4762 : }
4763 :
4764 0 : entity = tableEntity["CalFocusModel"];
4765 0 : if (entity.getEntityId().getId().length() != 0) {
4766 0 : getCalFocusModel().setFromFile(directory_);
4767 : }
4768 :
4769 0 : entity = tableEntity["CalGain"];
4770 0 : if (entity.getEntityId().getId().length() != 0) {
4771 0 : getCalGain().setFromFile(directory_);
4772 : }
4773 :
4774 0 : entity = tableEntity["CalHolography"];
4775 0 : if (entity.getEntityId().getId().length() != 0) {
4776 0 : getCalHolography().setFromFile(directory_);
4777 : }
4778 :
4779 0 : entity = tableEntity["CalPhase"];
4780 0 : if (entity.getEntityId().getId().length() != 0) {
4781 0 : getCalPhase().setFromFile(directory_);
4782 : }
4783 :
4784 0 : entity = tableEntity["CalPointing"];
4785 0 : if (entity.getEntityId().getId().length() != 0) {
4786 0 : getCalPointing().setFromFile(directory_);
4787 : }
4788 :
4789 0 : entity = tableEntity["CalPointingModel"];
4790 0 : if (entity.getEntityId().getId().length() != 0) {
4791 0 : getCalPointingModel().setFromFile(directory_);
4792 : }
4793 :
4794 0 : entity = tableEntity["CalPosition"];
4795 0 : if (entity.getEntityId().getId().length() != 0) {
4796 0 : getCalPosition().setFromFile(directory_);
4797 : }
4798 :
4799 0 : entity = tableEntity["CalPrimaryBeam"];
4800 0 : if (entity.getEntityId().getId().length() != 0) {
4801 0 : getCalPrimaryBeam().setFromFile(directory_);
4802 : }
4803 :
4804 0 : entity = tableEntity["CalReduction"];
4805 0 : if (entity.getEntityId().getId().length() != 0) {
4806 0 : getCalReduction().setFromFile(directory_);
4807 : }
4808 :
4809 0 : entity = tableEntity["CalSeeing"];
4810 0 : if (entity.getEntityId().getId().length() != 0) {
4811 0 : getCalSeeing().setFromFile(directory_);
4812 : }
4813 :
4814 0 : entity = tableEntity["CalWVR"];
4815 0 : if (entity.getEntityId().getId().length() != 0) {
4816 0 : getCalWVR().setFromFile(directory_);
4817 : }
4818 :
4819 0 : entity = tableEntity["ConfigDescription"];
4820 0 : if (entity.getEntityId().getId().length() != 0) {
4821 0 : getConfigDescription().setFromFile(directory_);
4822 : }
4823 :
4824 0 : entity = tableEntity["CorrelatorMode"];
4825 0 : if (entity.getEntityId().getId().length() != 0) {
4826 0 : getCorrelatorMode().setFromFile(directory_);
4827 : }
4828 :
4829 0 : entity = tableEntity["DataDescription"];
4830 0 : if (entity.getEntityId().getId().length() != 0) {
4831 0 : getDataDescription().setFromFile(directory_);
4832 : }
4833 :
4834 0 : entity = tableEntity["DelayModel"];
4835 0 : if (entity.getEntityId().getId().length() != 0) {
4836 0 : getDelayModel().setFromFile(directory_);
4837 : }
4838 :
4839 0 : entity = tableEntity["DelayModelFixedParameters"];
4840 0 : if (entity.getEntityId().getId().length() != 0) {
4841 0 : getDelayModelFixedParameters().setFromFile(directory_);
4842 : }
4843 :
4844 0 : entity = tableEntity["DelayModelVariableParameters"];
4845 0 : if (entity.getEntityId().getId().length() != 0) {
4846 0 : getDelayModelVariableParameters().setFromFile(directory_);
4847 : }
4848 :
4849 0 : entity = tableEntity["Doppler"];
4850 0 : if (entity.getEntityId().getId().length() != 0) {
4851 0 : getDoppler().setFromFile(directory_);
4852 : }
4853 :
4854 0 : entity = tableEntity["Ephemeris"];
4855 0 : if (entity.getEntityId().getId().length() != 0) {
4856 0 : getEphemeris().setFromFile(directory_);
4857 : }
4858 :
4859 0 : entity = tableEntity["ExecBlock"];
4860 0 : if (entity.getEntityId().getId().length() != 0) {
4861 0 : getExecBlock().setFromFile(directory_);
4862 : }
4863 :
4864 0 : entity = tableEntity["Feed"];
4865 0 : if (entity.getEntityId().getId().length() != 0) {
4866 0 : getFeed().setFromFile(directory_);
4867 : }
4868 :
4869 0 : entity = tableEntity["Field"];
4870 0 : if (entity.getEntityId().getId().length() != 0) {
4871 0 : getField().setFromFile(directory_);
4872 : }
4873 :
4874 0 : entity = tableEntity["Flag"];
4875 0 : if (entity.getEntityId().getId().length() != 0) {
4876 0 : getFlag().setFromFile(directory_);
4877 : }
4878 :
4879 0 : entity = tableEntity["FlagCmd"];
4880 0 : if (entity.getEntityId().getId().length() != 0) {
4881 0 : getFlagCmd().setFromFile(directory_);
4882 : }
4883 :
4884 0 : entity = tableEntity["Focus"];
4885 0 : if (entity.getEntityId().getId().length() != 0) {
4886 0 : getFocus().setFromFile(directory_);
4887 : }
4888 :
4889 0 : entity = tableEntity["FocusModel"];
4890 0 : if (entity.getEntityId().getId().length() != 0) {
4891 0 : getFocusModel().setFromFile(directory_);
4892 : }
4893 :
4894 0 : entity = tableEntity["FreqOffset"];
4895 0 : if (entity.getEntityId().getId().length() != 0) {
4896 0 : getFreqOffset().setFromFile(directory_);
4897 : }
4898 :
4899 0 : entity = tableEntity["GainTracking"];
4900 0 : if (entity.getEntityId().getId().length() != 0) {
4901 0 : getGainTracking().setFromFile(directory_);
4902 : }
4903 :
4904 0 : entity = tableEntity["History"];
4905 0 : if (entity.getEntityId().getId().length() != 0) {
4906 0 : getHistory().setFromFile(directory_);
4907 : }
4908 :
4909 0 : entity = tableEntity["Holography"];
4910 0 : if (entity.getEntityId().getId().length() != 0) {
4911 0 : getHolography().setFromFile(directory_);
4912 : }
4913 :
4914 0 : entity = tableEntity["Observation"];
4915 0 : if (entity.getEntityId().getId().length() != 0) {
4916 0 : getObservation().setFromFile(directory_);
4917 : }
4918 :
4919 0 : entity = tableEntity["Pointing"];
4920 0 : if (entity.getEntityId().getId().length() != 0) {
4921 0 : getPointing().setFromFile(directory_);
4922 : }
4923 :
4924 0 : entity = tableEntity["PointingModel"];
4925 0 : if (entity.getEntityId().getId().length() != 0) {
4926 0 : getPointingModel().setFromFile(directory_);
4927 : }
4928 :
4929 0 : entity = tableEntity["Polarization"];
4930 0 : if (entity.getEntityId().getId().length() != 0) {
4931 0 : getPolarization().setFromFile(directory_);
4932 : }
4933 :
4934 0 : entity = tableEntity["Processor"];
4935 0 : if (entity.getEntityId().getId().length() != 0) {
4936 0 : getProcessor().setFromFile(directory_);
4937 : }
4938 :
4939 0 : entity = tableEntity["Pulsar"];
4940 0 : if (entity.getEntityId().getId().length() != 0) {
4941 0 : getPulsar().setFromFile(directory_);
4942 : }
4943 :
4944 0 : entity = tableEntity["Receiver"];
4945 0 : if (entity.getEntityId().getId().length() != 0) {
4946 0 : getReceiver().setFromFile(directory_);
4947 : }
4948 :
4949 0 : entity = tableEntity["SBSummary"];
4950 0 : if (entity.getEntityId().getId().length() != 0) {
4951 0 : getSBSummary().setFromFile(directory_);
4952 : }
4953 :
4954 0 : entity = tableEntity["Scale"];
4955 0 : if (entity.getEntityId().getId().length() != 0) {
4956 0 : getScale().setFromFile(directory_);
4957 : }
4958 :
4959 0 : entity = tableEntity["Scan"];
4960 0 : if (entity.getEntityId().getId().length() != 0) {
4961 0 : getScan().setFromFile(directory_);
4962 : }
4963 :
4964 0 : entity = tableEntity["Seeing"];
4965 0 : if (entity.getEntityId().getId().length() != 0) {
4966 0 : getSeeing().setFromFile(directory_);
4967 : }
4968 :
4969 0 : entity = tableEntity["Source"];
4970 0 : if (entity.getEntityId().getId().length() != 0) {
4971 0 : getSource().setFromFile(directory_);
4972 : }
4973 :
4974 0 : entity = tableEntity["SpectralWindow"];
4975 0 : if (entity.getEntityId().getId().length() != 0) {
4976 0 : getSpectralWindow().setFromFile(directory_);
4977 : }
4978 :
4979 0 : entity = tableEntity["SquareLawDetector"];
4980 0 : if (entity.getEntityId().getId().length() != 0) {
4981 0 : getSquareLawDetector().setFromFile(directory_);
4982 : }
4983 :
4984 0 : entity = tableEntity["State"];
4985 0 : if (entity.getEntityId().getId().length() != 0) {
4986 0 : getState().setFromFile(directory_);
4987 : }
4988 :
4989 0 : entity = tableEntity["Station"];
4990 0 : if (entity.getEntityId().getId().length() != 0) {
4991 0 : getStation().setFromFile(directory_);
4992 : }
4993 :
4994 0 : entity = tableEntity["Subscan"];
4995 0 : if (entity.getEntityId().getId().length() != 0) {
4996 0 : getSubscan().setFromFile(directory_);
4997 : }
4998 :
4999 0 : entity = tableEntity["SwitchCycle"];
5000 0 : if (entity.getEntityId().getId().length() != 0) {
5001 0 : getSwitchCycle().setFromFile(directory_);
5002 : }
5003 :
5004 0 : entity = tableEntity["SysCal"];
5005 0 : if (entity.getEntityId().getId().length() != 0) {
5006 0 : getSysCal().setFromFile(directory_);
5007 : }
5008 :
5009 0 : entity = tableEntity["SysPower"];
5010 0 : if (entity.getEntityId().getId().length() != 0) {
5011 0 : getSysPower().setFromFile(directory_);
5012 : }
5013 :
5014 0 : entity = tableEntity["TotalPower"];
5015 0 : if (entity.getEntityId().getId().length() != 0) {
5016 0 : getTotalPower().setFromFile(directory_);
5017 : }
5018 :
5019 0 : entity = tableEntity["VLAWVR"];
5020 0 : if (entity.getEntityId().getId().length() != 0) {
5021 0 : getVLAWVR().setFromFile(directory_);
5022 : }
5023 :
5024 0 : entity = tableEntity["WVMCal"];
5025 0 : if (entity.getEntityId().getId().length() != 0) {
5026 0 : getWVMCal().setFromFile(directory_);
5027 : }
5028 :
5029 0 : entity = tableEntity["Weather"];
5030 0 : if (entity.getEntityId().getId().length() != 0) {
5031 0 : getWeather().setFromFile(directory_);
5032 : }
5033 :
5034 : }
5035 : else {
5036 :
5037 83 : getMain().presentInMemory = tableEntity["Main"].getEntityId().getId().length() == 0;
5038 :
5039 83 : getAlmaRadiometer().presentInMemory = tableEntity["AlmaRadiometer"].getEntityId().getId().length() == 0;
5040 :
5041 83 : getAnnotation().presentInMemory = tableEntity["Annotation"].getEntityId().getId().length() == 0;
5042 :
5043 83 : getAntenna().presentInMemory = tableEntity["Antenna"].getEntityId().getId().length() == 0;
5044 :
5045 83 : getCalAmpli().presentInMemory = tableEntity["CalAmpli"].getEntityId().getId().length() == 0;
5046 :
5047 83 : getCalAntennaSolutions().presentInMemory = tableEntity["CalAntennaSolutions"].getEntityId().getId().length() == 0;
5048 :
5049 83 : getCalAppPhase().presentInMemory = tableEntity["CalAppPhase"].getEntityId().getId().length() == 0;
5050 :
5051 83 : getCalAtmosphere().presentInMemory = tableEntity["CalAtmosphere"].getEntityId().getId().length() == 0;
5052 :
5053 83 : getCalBandpass().presentInMemory = tableEntity["CalBandpass"].getEntityId().getId().length() == 0;
5054 :
5055 83 : getCalCurve().presentInMemory = tableEntity["CalCurve"].getEntityId().getId().length() == 0;
5056 :
5057 83 : getCalData().presentInMemory = tableEntity["CalData"].getEntityId().getId().length() == 0;
5058 :
5059 83 : getCalDelay().presentInMemory = tableEntity["CalDelay"].getEntityId().getId().length() == 0;
5060 :
5061 83 : getCalDevice().presentInMemory = tableEntity["CalDevice"].getEntityId().getId().length() == 0;
5062 :
5063 83 : getCalFlux().presentInMemory = tableEntity["CalFlux"].getEntityId().getId().length() == 0;
5064 :
5065 83 : getCalFocus().presentInMemory = tableEntity["CalFocus"].getEntityId().getId().length() == 0;
5066 :
5067 83 : getCalFocusModel().presentInMemory = tableEntity["CalFocusModel"].getEntityId().getId().length() == 0;
5068 :
5069 83 : getCalGain().presentInMemory = tableEntity["CalGain"].getEntityId().getId().length() == 0;
5070 :
5071 83 : getCalHolography().presentInMemory = tableEntity["CalHolography"].getEntityId().getId().length() == 0;
5072 :
5073 83 : getCalPhase().presentInMemory = tableEntity["CalPhase"].getEntityId().getId().length() == 0;
5074 :
5075 83 : getCalPointing().presentInMemory = tableEntity["CalPointing"].getEntityId().getId().length() == 0;
5076 :
5077 83 : getCalPointingModel().presentInMemory = tableEntity["CalPointingModel"].getEntityId().getId().length() == 0;
5078 :
5079 83 : getCalPosition().presentInMemory = tableEntity["CalPosition"].getEntityId().getId().length() == 0;
5080 :
5081 83 : getCalPrimaryBeam().presentInMemory = tableEntity["CalPrimaryBeam"].getEntityId().getId().length() == 0;
5082 :
5083 83 : getCalReduction().presentInMemory = tableEntity["CalReduction"].getEntityId().getId().length() == 0;
5084 :
5085 83 : getCalSeeing().presentInMemory = tableEntity["CalSeeing"].getEntityId().getId().length() == 0;
5086 :
5087 83 : getCalWVR().presentInMemory = tableEntity["CalWVR"].getEntityId().getId().length() == 0;
5088 :
5089 83 : getConfigDescription().presentInMemory = tableEntity["ConfigDescription"].getEntityId().getId().length() == 0;
5090 :
5091 83 : getCorrelatorMode().presentInMemory = tableEntity["CorrelatorMode"].getEntityId().getId().length() == 0;
5092 :
5093 83 : getDataDescription().presentInMemory = tableEntity["DataDescription"].getEntityId().getId().length() == 0;
5094 :
5095 83 : getDelayModel().presentInMemory = tableEntity["DelayModel"].getEntityId().getId().length() == 0;
5096 :
5097 83 : getDelayModelFixedParameters().presentInMemory = tableEntity["DelayModelFixedParameters"].getEntityId().getId().length() == 0;
5098 :
5099 83 : getDelayModelVariableParameters().presentInMemory = tableEntity["DelayModelVariableParameters"].getEntityId().getId().length() == 0;
5100 :
5101 83 : getDoppler().presentInMemory = tableEntity["Doppler"].getEntityId().getId().length() == 0;
5102 :
5103 83 : getEphemeris().presentInMemory = tableEntity["Ephemeris"].getEntityId().getId().length() == 0;
5104 :
5105 83 : getExecBlock().presentInMemory = tableEntity["ExecBlock"].getEntityId().getId().length() == 0;
5106 :
5107 83 : getFeed().presentInMemory = tableEntity["Feed"].getEntityId().getId().length() == 0;
5108 :
5109 83 : getField().presentInMemory = tableEntity["Field"].getEntityId().getId().length() == 0;
5110 :
5111 83 : getFlag().presentInMemory = tableEntity["Flag"].getEntityId().getId().length() == 0;
5112 :
5113 83 : getFlagCmd().presentInMemory = tableEntity["FlagCmd"].getEntityId().getId().length() == 0;
5114 :
5115 83 : getFocus().presentInMemory = tableEntity["Focus"].getEntityId().getId().length() == 0;
5116 :
5117 83 : getFocusModel().presentInMemory = tableEntity["FocusModel"].getEntityId().getId().length() == 0;
5118 :
5119 83 : getFreqOffset().presentInMemory = tableEntity["FreqOffset"].getEntityId().getId().length() == 0;
5120 :
5121 83 : getGainTracking().presentInMemory = tableEntity["GainTracking"].getEntityId().getId().length() == 0;
5122 :
5123 83 : getHistory().presentInMemory = tableEntity["History"].getEntityId().getId().length() == 0;
5124 :
5125 83 : getHolography().presentInMemory = tableEntity["Holography"].getEntityId().getId().length() == 0;
5126 :
5127 83 : getObservation().presentInMemory = tableEntity["Observation"].getEntityId().getId().length() == 0;
5128 :
5129 83 : getPointing().presentInMemory = tableEntity["Pointing"].getEntityId().getId().length() == 0;
5130 :
5131 83 : getPointingModel().presentInMemory = tableEntity["PointingModel"].getEntityId().getId().length() == 0;
5132 :
5133 83 : getPolarization().presentInMemory = tableEntity["Polarization"].getEntityId().getId().length() == 0;
5134 :
5135 83 : getProcessor().presentInMemory = tableEntity["Processor"].getEntityId().getId().length() == 0;
5136 :
5137 83 : getPulsar().presentInMemory = tableEntity["Pulsar"].getEntityId().getId().length() == 0;
5138 :
5139 83 : getReceiver().presentInMemory = tableEntity["Receiver"].getEntityId().getId().length() == 0;
5140 :
5141 83 : getSBSummary().presentInMemory = tableEntity["SBSummary"].getEntityId().getId().length() == 0;
5142 :
5143 83 : getScale().presentInMemory = tableEntity["Scale"].getEntityId().getId().length() == 0;
5144 :
5145 83 : getScan().presentInMemory = tableEntity["Scan"].getEntityId().getId().length() == 0;
5146 :
5147 83 : getSeeing().presentInMemory = tableEntity["Seeing"].getEntityId().getId().length() == 0;
5148 :
5149 83 : getSource().presentInMemory = tableEntity["Source"].getEntityId().getId().length() == 0;
5150 :
5151 83 : getSpectralWindow().presentInMemory = tableEntity["SpectralWindow"].getEntityId().getId().length() == 0;
5152 :
5153 83 : getSquareLawDetector().presentInMemory = tableEntity["SquareLawDetector"].getEntityId().getId().length() == 0;
5154 :
5155 83 : getState().presentInMemory = tableEntity["State"].getEntityId().getId().length() == 0;
5156 :
5157 83 : getStation().presentInMemory = tableEntity["Station"].getEntityId().getId().length() == 0;
5158 :
5159 83 : getSubscan().presentInMemory = tableEntity["Subscan"].getEntityId().getId().length() == 0;
5160 :
5161 83 : getSwitchCycle().presentInMemory = tableEntity["SwitchCycle"].getEntityId().getId().length() == 0;
5162 :
5163 83 : getSysCal().presentInMemory = tableEntity["SysCal"].getEntityId().getId().length() == 0;
5164 :
5165 83 : getSysPower().presentInMemory = tableEntity["SysPower"].getEntityId().getId().length() == 0;
5166 :
5167 83 : getTotalPower().presentInMemory = tableEntity["TotalPower"].getEntityId().getId().length() == 0;
5168 :
5169 83 : getVLAWVR().presentInMemory = tableEntity["VLAWVR"].getEntityId().getId().length() == 0;
5170 :
5171 83 : getWVMCal().presentInMemory = tableEntity["WVMCal"].getEntityId().getId().length() == 0;
5172 :
5173 83 : getWeather().presentInMemory = tableEntity["Weather"].getEntityId().getId().length() == 0;
5174 :
5175 : }
5176 :
5177 83 : origin = FILE;
5178 83 : }
5179 :
5180 1568 : bool ASDM::checkRowUniqueness() const { return checkRowUniqueness_; }
5181 :
5182 :
5183 :
5184 :
5185 :
5186 340 : Entity ASDM::getEntity() const {
5187 340 : return entity;
5188 : }
5189 :
5190 97 : void ASDM::setEntity(Entity e) {
5191 97 : this->entity = e;
5192 97 : }
5193 :
5194 : /**
5195 : * Meaningless, but required for the Representable interface.
5196 : */
5197 0 : string ASDM::getName() const {
5198 0 : return "";
5199 : }
5200 :
5201 : /**
5202 : * Meaningless, but required for the Representable interface.
5203 : */
5204 0 : unsigned int ASDM::size() {
5205 0 : return 0;
5206 : }
5207 :
5208 : #ifndef WITHOUT_ACS
5209 : /**
5210 : * Create an ASDM dataset from the ALMA archive, given the
5211 : * entityId of its container.
5212 : * @param datasetId The entityId of the container of the dataset.
5213 : */
5214 : ASDM *ASDM::fromArchive(EntityId datasetId) {
5215 : // Get the xml representation of the container.
5216 : string xml = getXMLEntity(datasetId);
5217 : // Create the container ...
5218 : ASDM *container = new ASDM ();
5219 : // ... and populate it with data.
5220 : container->fromXML(xml);
5221 :
5222 : // Now build the tables.
5223 : Entity entity;
5224 :
5225 : entity = container->tableEntity["Main"];
5226 : if (entity.getEntityId().getId().size() != 0) {
5227 : container->getMain().setEntity(entity);
5228 : xml = getXMLEntity(entity.getEntityId());
5229 : container->getMain().fromXML(xml);
5230 : }
5231 :
5232 : entity = container->tableEntity["AlmaRadiometer"];
5233 : if (entity.getEntityId().getId().size() != 0) {
5234 : container->getAlmaRadiometer().setEntity(entity);
5235 : xml = getXMLEntity(entity.getEntityId());
5236 : container->getAlmaRadiometer().fromXML(xml);
5237 : }
5238 :
5239 : entity = container->tableEntity["Annotation"];
5240 : if (entity.getEntityId().getId().size() != 0) {
5241 : container->getAnnotation().setEntity(entity);
5242 : xml = getXMLEntity(entity.getEntityId());
5243 : container->getAnnotation().fromXML(xml);
5244 : }
5245 :
5246 : entity = container->tableEntity["Antenna"];
5247 : if (entity.getEntityId().getId().size() != 0) {
5248 : container->getAntenna().setEntity(entity);
5249 : xml = getXMLEntity(entity.getEntityId());
5250 : container->getAntenna().fromXML(xml);
5251 : }
5252 :
5253 : entity = container->tableEntity["CalAmpli"];
5254 : if (entity.getEntityId().getId().size() != 0) {
5255 : container->getCalAmpli().setEntity(entity);
5256 : xml = getXMLEntity(entity.getEntityId());
5257 : container->getCalAmpli().fromXML(xml);
5258 : }
5259 :
5260 : entity = container->tableEntity["CalAntennaSolutions"];
5261 : if (entity.getEntityId().getId().size() != 0) {
5262 : container->getCalAntennaSolutions().setEntity(entity);
5263 : xml = getXMLEntity(entity.getEntityId());
5264 : container->getCalAntennaSolutions().fromXML(xml);
5265 : }
5266 :
5267 : entity = container->tableEntity["CalAppPhase"];
5268 : if (entity.getEntityId().getId().size() != 0) {
5269 : container->getCalAppPhase().setEntity(entity);
5270 : xml = getXMLEntity(entity.getEntityId());
5271 : container->getCalAppPhase().fromXML(xml);
5272 : }
5273 :
5274 : entity = container->tableEntity["CalAtmosphere"];
5275 : if (entity.getEntityId().getId().size() != 0) {
5276 : container->getCalAtmosphere().setEntity(entity);
5277 : xml = getXMLEntity(entity.getEntityId());
5278 : container->getCalAtmosphere().fromXML(xml);
5279 : }
5280 :
5281 : entity = container->tableEntity["CalBandpass"];
5282 : if (entity.getEntityId().getId().size() != 0) {
5283 : container->getCalBandpass().setEntity(entity);
5284 : xml = getXMLEntity(entity.getEntityId());
5285 : container->getCalBandpass().fromXML(xml);
5286 : }
5287 :
5288 : entity = container->tableEntity["CalCurve"];
5289 : if (entity.getEntityId().getId().size() != 0) {
5290 : container->getCalCurve().setEntity(entity);
5291 : xml = getXMLEntity(entity.getEntityId());
5292 : container->getCalCurve().fromXML(xml);
5293 : }
5294 :
5295 : entity = container->tableEntity["CalData"];
5296 : if (entity.getEntityId().getId().size() != 0) {
5297 : container->getCalData().setEntity(entity);
5298 : xml = getXMLEntity(entity.getEntityId());
5299 : container->getCalData().fromXML(xml);
5300 : }
5301 :
5302 : entity = container->tableEntity["CalDelay"];
5303 : if (entity.getEntityId().getId().size() != 0) {
5304 : container->getCalDelay().setEntity(entity);
5305 : xml = getXMLEntity(entity.getEntityId());
5306 : container->getCalDelay().fromXML(xml);
5307 : }
5308 :
5309 : entity = container->tableEntity["CalDevice"];
5310 : if (entity.getEntityId().getId().size() != 0) {
5311 : container->getCalDevice().setEntity(entity);
5312 : xml = getXMLEntity(entity.getEntityId());
5313 : container->getCalDevice().fromXML(xml);
5314 : }
5315 :
5316 : entity = container->tableEntity["CalFlux"];
5317 : if (entity.getEntityId().getId().size() != 0) {
5318 : container->getCalFlux().setEntity(entity);
5319 : xml = getXMLEntity(entity.getEntityId());
5320 : container->getCalFlux().fromXML(xml);
5321 : }
5322 :
5323 : entity = container->tableEntity["CalFocus"];
5324 : if (entity.getEntityId().getId().size() != 0) {
5325 : container->getCalFocus().setEntity(entity);
5326 : xml = getXMLEntity(entity.getEntityId());
5327 : container->getCalFocus().fromXML(xml);
5328 : }
5329 :
5330 : entity = container->tableEntity["CalFocusModel"];
5331 : if (entity.getEntityId().getId().size() != 0) {
5332 : container->getCalFocusModel().setEntity(entity);
5333 : xml = getXMLEntity(entity.getEntityId());
5334 : container->getCalFocusModel().fromXML(xml);
5335 : }
5336 :
5337 : entity = container->tableEntity["CalGain"];
5338 : if (entity.getEntityId().getId().size() != 0) {
5339 : container->getCalGain().setEntity(entity);
5340 : xml = getXMLEntity(entity.getEntityId());
5341 : container->getCalGain().fromXML(xml);
5342 : }
5343 :
5344 : entity = container->tableEntity["CalHolography"];
5345 : if (entity.getEntityId().getId().size() != 0) {
5346 : container->getCalHolography().setEntity(entity);
5347 : xml = getXMLEntity(entity.getEntityId());
5348 : container->getCalHolography().fromXML(xml);
5349 : }
5350 :
5351 : entity = container->tableEntity["CalPhase"];
5352 : if (entity.getEntityId().getId().size() != 0) {
5353 : container->getCalPhase().setEntity(entity);
5354 : xml = getXMLEntity(entity.getEntityId());
5355 : container->getCalPhase().fromXML(xml);
5356 : }
5357 :
5358 : entity = container->tableEntity["CalPointing"];
5359 : if (entity.getEntityId().getId().size() != 0) {
5360 : container->getCalPointing().setEntity(entity);
5361 : xml = getXMLEntity(entity.getEntityId());
5362 : container->getCalPointing().fromXML(xml);
5363 : }
5364 :
5365 : entity = container->tableEntity["CalPointingModel"];
5366 : if (entity.getEntityId().getId().size() != 0) {
5367 : container->getCalPointingModel().setEntity(entity);
5368 : xml = getXMLEntity(entity.getEntityId());
5369 : container->getCalPointingModel().fromXML(xml);
5370 : }
5371 :
5372 : entity = container->tableEntity["CalPosition"];
5373 : if (entity.getEntityId().getId().size() != 0) {
5374 : container->getCalPosition().setEntity(entity);
5375 : xml = getXMLEntity(entity.getEntityId());
5376 : container->getCalPosition().fromXML(xml);
5377 : }
5378 :
5379 : entity = container->tableEntity["CalPrimaryBeam"];
5380 : if (entity.getEntityId().getId().size() != 0) {
5381 : container->getCalPrimaryBeam().setEntity(entity);
5382 : xml = getXMLEntity(entity.getEntityId());
5383 : container->getCalPrimaryBeam().fromXML(xml);
5384 : }
5385 :
5386 : entity = container->tableEntity["CalReduction"];
5387 : if (entity.getEntityId().getId().size() != 0) {
5388 : container->getCalReduction().setEntity(entity);
5389 : xml = getXMLEntity(entity.getEntityId());
5390 : container->getCalReduction().fromXML(xml);
5391 : }
5392 :
5393 : entity = container->tableEntity["CalSeeing"];
5394 : if (entity.getEntityId().getId().size() != 0) {
5395 : container->getCalSeeing().setEntity(entity);
5396 : xml = getXMLEntity(entity.getEntityId());
5397 : container->getCalSeeing().fromXML(xml);
5398 : }
5399 :
5400 : entity = container->tableEntity["CalWVR"];
5401 : if (entity.getEntityId().getId().size() != 0) {
5402 : container->getCalWVR().setEntity(entity);
5403 : xml = getXMLEntity(entity.getEntityId());
5404 : container->getCalWVR().fromXML(xml);
5405 : }
5406 :
5407 : entity = container->tableEntity["ConfigDescription"];
5408 : if (entity.getEntityId().getId().size() != 0) {
5409 : container->getConfigDescription().setEntity(entity);
5410 : xml = getXMLEntity(entity.getEntityId());
5411 : container->getConfigDescription().fromXML(xml);
5412 : }
5413 :
5414 : entity = container->tableEntity["CorrelatorMode"];
5415 : if (entity.getEntityId().getId().size() != 0) {
5416 : container->getCorrelatorMode().setEntity(entity);
5417 : xml = getXMLEntity(entity.getEntityId());
5418 : container->getCorrelatorMode().fromXML(xml);
5419 : }
5420 :
5421 : entity = container->tableEntity["DataDescription"];
5422 : if (entity.getEntityId().getId().size() != 0) {
5423 : container->getDataDescription().setEntity(entity);
5424 : xml = getXMLEntity(entity.getEntityId());
5425 : container->getDataDescription().fromXML(xml);
5426 : }
5427 :
5428 : entity = container->tableEntity["DelayModel"];
5429 : if (entity.getEntityId().getId().size() != 0) {
5430 : container->getDelayModel().setEntity(entity);
5431 : xml = getXMLEntity(entity.getEntityId());
5432 : container->getDelayModel().fromXML(xml);
5433 : }
5434 :
5435 : entity = container->tableEntity["DelayModelFixedParameters"];
5436 : if (entity.getEntityId().getId().size() != 0) {
5437 : container->getDelayModelFixedParameters().setEntity(entity);
5438 : xml = getXMLEntity(entity.getEntityId());
5439 : container->getDelayModelFixedParameters().fromXML(xml);
5440 : }
5441 :
5442 : entity = container->tableEntity["DelayModelVariableParameters"];
5443 : if (entity.getEntityId().getId().size() != 0) {
5444 : container->getDelayModelVariableParameters().setEntity(entity);
5445 : xml = getXMLEntity(entity.getEntityId());
5446 : container->getDelayModelVariableParameters().fromXML(xml);
5447 : }
5448 :
5449 : entity = container->tableEntity["Doppler"];
5450 : if (entity.getEntityId().getId().size() != 0) {
5451 : container->getDoppler().setEntity(entity);
5452 : xml = getXMLEntity(entity.getEntityId());
5453 : container->getDoppler().fromXML(xml);
5454 : }
5455 :
5456 : entity = container->tableEntity["Ephemeris"];
5457 : if (entity.getEntityId().getId().size() != 0) {
5458 : container->getEphemeris().setEntity(entity);
5459 : xml = getXMLEntity(entity.getEntityId());
5460 : container->getEphemeris().fromXML(xml);
5461 : }
5462 :
5463 : entity = container->tableEntity["ExecBlock"];
5464 : if (entity.getEntityId().getId().size() != 0) {
5465 : container->getExecBlock().setEntity(entity);
5466 : xml = getXMLEntity(entity.getEntityId());
5467 : container->getExecBlock().fromXML(xml);
5468 : }
5469 :
5470 : entity = container->tableEntity["Feed"];
5471 : if (entity.getEntityId().getId().size() != 0) {
5472 : container->getFeed().setEntity(entity);
5473 : xml = getXMLEntity(entity.getEntityId());
5474 : container->getFeed().fromXML(xml);
5475 : }
5476 :
5477 : entity = container->tableEntity["Field"];
5478 : if (entity.getEntityId().getId().size() != 0) {
5479 : container->getField().setEntity(entity);
5480 : xml = getXMLEntity(entity.getEntityId());
5481 : container->getField().fromXML(xml);
5482 : }
5483 :
5484 : entity = container->tableEntity["Flag"];
5485 : if (entity.getEntityId().getId().size() != 0) {
5486 : container->getFlag().setEntity(entity);
5487 : xml = getXMLEntity(entity.getEntityId());
5488 : container->getFlag().fromXML(xml);
5489 : }
5490 :
5491 : entity = container->tableEntity["FlagCmd"];
5492 : if (entity.getEntityId().getId().size() != 0) {
5493 : container->getFlagCmd().setEntity(entity);
5494 : xml = getXMLEntity(entity.getEntityId());
5495 : container->getFlagCmd().fromXML(xml);
5496 : }
5497 :
5498 : entity = container->tableEntity["Focus"];
5499 : if (entity.getEntityId().getId().size() != 0) {
5500 : container->getFocus().setEntity(entity);
5501 : xml = getXMLEntity(entity.getEntityId());
5502 : container->getFocus().fromXML(xml);
5503 : }
5504 :
5505 : entity = container->tableEntity["FocusModel"];
5506 : if (entity.getEntityId().getId().size() != 0) {
5507 : container->getFocusModel().setEntity(entity);
5508 : xml = getXMLEntity(entity.getEntityId());
5509 : container->getFocusModel().fromXML(xml);
5510 : }
5511 :
5512 : entity = container->tableEntity["FreqOffset"];
5513 : if (entity.getEntityId().getId().size() != 0) {
5514 : container->getFreqOffset().setEntity(entity);
5515 : xml = getXMLEntity(entity.getEntityId());
5516 : container->getFreqOffset().fromXML(xml);
5517 : }
5518 :
5519 : entity = container->tableEntity["GainTracking"];
5520 : if (entity.getEntityId().getId().size() != 0) {
5521 : container->getGainTracking().setEntity(entity);
5522 : xml = getXMLEntity(entity.getEntityId());
5523 : container->getGainTracking().fromXML(xml);
5524 : }
5525 :
5526 : entity = container->tableEntity["History"];
5527 : if (entity.getEntityId().getId().size() != 0) {
5528 : container->getHistory().setEntity(entity);
5529 : xml = getXMLEntity(entity.getEntityId());
5530 : container->getHistory().fromXML(xml);
5531 : }
5532 :
5533 : entity = container->tableEntity["Holography"];
5534 : if (entity.getEntityId().getId().size() != 0) {
5535 : container->getHolography().setEntity(entity);
5536 : xml = getXMLEntity(entity.getEntityId());
5537 : container->getHolography().fromXML(xml);
5538 : }
5539 :
5540 : entity = container->tableEntity["Observation"];
5541 : if (entity.getEntityId().getId().size() != 0) {
5542 : container->getObservation().setEntity(entity);
5543 : xml = getXMLEntity(entity.getEntityId());
5544 : container->getObservation().fromXML(xml);
5545 : }
5546 :
5547 : entity = container->tableEntity["Pointing"];
5548 : if (entity.getEntityId().getId().size() != 0) {
5549 : container->getPointing().setEntity(entity);
5550 : xml = getXMLEntity(entity.getEntityId());
5551 : container->getPointing().fromXML(xml);
5552 : }
5553 :
5554 : entity = container->tableEntity["PointingModel"];
5555 : if (entity.getEntityId().getId().size() != 0) {
5556 : container->getPointingModel().setEntity(entity);
5557 : xml = getXMLEntity(entity.getEntityId());
5558 : container->getPointingModel().fromXML(xml);
5559 : }
5560 :
5561 : entity = container->tableEntity["Polarization"];
5562 : if (entity.getEntityId().getId().size() != 0) {
5563 : container->getPolarization().setEntity(entity);
5564 : xml = getXMLEntity(entity.getEntityId());
5565 : container->getPolarization().fromXML(xml);
5566 : }
5567 :
5568 : entity = container->tableEntity["Processor"];
5569 : if (entity.getEntityId().getId().size() != 0) {
5570 : container->getProcessor().setEntity(entity);
5571 : xml = getXMLEntity(entity.getEntityId());
5572 : container->getProcessor().fromXML(xml);
5573 : }
5574 :
5575 : entity = container->tableEntity["Pulsar"];
5576 : if (entity.getEntityId().getId().size() != 0) {
5577 : container->getPulsar().setEntity(entity);
5578 : xml = getXMLEntity(entity.getEntityId());
5579 : container->getPulsar().fromXML(xml);
5580 : }
5581 :
5582 : entity = container->tableEntity["Receiver"];
5583 : if (entity.getEntityId().getId().size() != 0) {
5584 : container->getReceiver().setEntity(entity);
5585 : xml = getXMLEntity(entity.getEntityId());
5586 : container->getReceiver().fromXML(xml);
5587 : }
5588 :
5589 : entity = container->tableEntity["SBSummary"];
5590 : if (entity.getEntityId().getId().size() != 0) {
5591 : container->getSBSummary().setEntity(entity);
5592 : xml = getXMLEntity(entity.getEntityId());
5593 : container->getSBSummary().fromXML(xml);
5594 : }
5595 :
5596 : entity = container->tableEntity["Scale"];
5597 : if (entity.getEntityId().getId().size() != 0) {
5598 : container->getScale().setEntity(entity);
5599 : xml = getXMLEntity(entity.getEntityId());
5600 : container->getScale().fromXML(xml);
5601 : }
5602 :
5603 : entity = container->tableEntity["Scan"];
5604 : if (entity.getEntityId().getId().size() != 0) {
5605 : container->getScan().setEntity(entity);
5606 : xml = getXMLEntity(entity.getEntityId());
5607 : container->getScan().fromXML(xml);
5608 : }
5609 :
5610 : entity = container->tableEntity["Seeing"];
5611 : if (entity.getEntityId().getId().size() != 0) {
5612 : container->getSeeing().setEntity(entity);
5613 : xml = getXMLEntity(entity.getEntityId());
5614 : container->getSeeing().fromXML(xml);
5615 : }
5616 :
5617 : entity = container->tableEntity["Source"];
5618 : if (entity.getEntityId().getId().size() != 0) {
5619 : container->getSource().setEntity(entity);
5620 : xml = getXMLEntity(entity.getEntityId());
5621 : container->getSource().fromXML(xml);
5622 : }
5623 :
5624 : entity = container->tableEntity["SpectralWindow"];
5625 : if (entity.getEntityId().getId().size() != 0) {
5626 : container->getSpectralWindow().setEntity(entity);
5627 : xml = getXMLEntity(entity.getEntityId());
5628 : container->getSpectralWindow().fromXML(xml);
5629 : }
5630 :
5631 : entity = container->tableEntity["SquareLawDetector"];
5632 : if (entity.getEntityId().getId().size() != 0) {
5633 : container->getSquareLawDetector().setEntity(entity);
5634 : xml = getXMLEntity(entity.getEntityId());
5635 : container->getSquareLawDetector().fromXML(xml);
5636 : }
5637 :
5638 : entity = container->tableEntity["State"];
5639 : if (entity.getEntityId().getId().size() != 0) {
5640 : container->getState().setEntity(entity);
5641 : xml = getXMLEntity(entity.getEntityId());
5642 : container->getState().fromXML(xml);
5643 : }
5644 :
5645 : entity = container->tableEntity["Station"];
5646 : if (entity.getEntityId().getId().size() != 0) {
5647 : container->getStation().setEntity(entity);
5648 : xml = getXMLEntity(entity.getEntityId());
5649 : container->getStation().fromXML(xml);
5650 : }
5651 :
5652 : entity = container->tableEntity["Subscan"];
5653 : if (entity.getEntityId().getId().size() != 0) {
5654 : container->getSubscan().setEntity(entity);
5655 : xml = getXMLEntity(entity.getEntityId());
5656 : container->getSubscan().fromXML(xml);
5657 : }
5658 :
5659 : entity = container->tableEntity["SwitchCycle"];
5660 : if (entity.getEntityId().getId().size() != 0) {
5661 : container->getSwitchCycle().setEntity(entity);
5662 : xml = getXMLEntity(entity.getEntityId());
5663 : container->getSwitchCycle().fromXML(xml);
5664 : }
5665 :
5666 : entity = container->tableEntity["SysCal"];
5667 : if (entity.getEntityId().getId().size() != 0) {
5668 : container->getSysCal().setEntity(entity);
5669 : xml = getXMLEntity(entity.getEntityId());
5670 : container->getSysCal().fromXML(xml);
5671 : }
5672 :
5673 : entity = container->tableEntity["SysPower"];
5674 : if (entity.getEntityId().getId().size() != 0) {
5675 : container->getSysPower().setEntity(entity);
5676 : xml = getXMLEntity(entity.getEntityId());
5677 : container->getSysPower().fromXML(xml);
5678 : }
5679 :
5680 : entity = container->tableEntity["TotalPower"];
5681 : if (entity.getEntityId().getId().size() != 0) {
5682 : container->getTotalPower().setEntity(entity);
5683 : xml = getXMLEntity(entity.getEntityId());
5684 : container->getTotalPower().fromXML(xml);
5685 : }
5686 :
5687 : entity = container->tableEntity["VLAWVR"];
5688 : if (entity.getEntityId().getId().size() != 0) {
5689 : container->getVLAWVR().setEntity(entity);
5690 : xml = getXMLEntity(entity.getEntityId());
5691 : container->getVLAWVR().fromXML(xml);
5692 : }
5693 :
5694 : entity = container->tableEntity["WVMCal"];
5695 : if (entity.getEntityId().getId().size() != 0) {
5696 : container->getWVMCal().setEntity(entity);
5697 : xml = getXMLEntity(entity.getEntityId());
5698 : container->getWVMCal().fromXML(xml);
5699 : }
5700 :
5701 : entity = container->tableEntity["Weather"];
5702 : if (entity.getEntityId().getId().size() != 0) {
5703 : container->getWeather().setEntity(entity);
5704 : xml = getXMLEntity(entity.getEntityId());
5705 : container->getWeather().fromXML(xml);
5706 : }
5707 :
5708 : return container;
5709 : }
5710 : #endif
5711 :
5712 : #ifndef WITHOUT_ACS
5713 : /**
5714 : * Update an ASDM dataset that already exists in the ALMA archive.
5715 : */
5716 : void ASDM::updateArchive() const{
5717 : // Assumption: Entity objects have already been assigned.
5718 : // Convert each table to an XML document and write it to the archive.
5719 : for (unsigned int i = 0; i < table.size(); ++i) {
5720 : string xml = table[i]->toXML();
5721 : putXMLEntity(xml);
5722 : }
5723 : // Now, convert the container and write it to the archive.
5724 : string xml = toXML();
5725 : putXMLEntity(xml);
5726 : }
5727 : #endif
5728 :
5729 : /**
5730 : * Return the table, as a Representable object, with the
5731 : * specified name.
5732 : */
5733 4486 : Representable &ASDM::getTable(string tableName) {
5734 163754 : for (unsigned int i = 0; i < table.size(); ++i)
5735 163749 : if (table[i]->getName() == tableName)
5736 4481 : return *table[i];
5737 5 : throw InvalidArgumentException("No such table as " + tableName);
5738 : }
5739 :
5740 :
5741 :
5742 :
5743 :
5744 : /**
5745 : * Get timeOfCreation.
5746 : * @return timeOfCreation as ArrayTime
5747 : */
5748 0 : ArrayTime ASDM::getTimeOfCreation() const {
5749 :
5750 0 : return timeOfCreation;
5751 : }
5752 :
5753 : /**
5754 : * Set timeOfCreation with the specified ArrayTime.
5755 : * @param timeOfCreation The ArrayTime value to which timeOfCreation is to be set.
5756 :
5757 :
5758 :
5759 : */
5760 0 : void ASDM::setTimeOfCreation (ArrayTime timeOfCreation) {
5761 :
5762 :
5763 0 : if (hasBeenAdded) {
5764 :
5765 : }
5766 :
5767 0 : this->timeOfCreation = timeOfCreation;
5768 :
5769 0 : }
5770 :
5771 :
5772 :
5773 :
5774 :
5775 :
5776 : /**
5777 : * Get version.
5778 : * @return version as int
5779 : */
5780 0 : int ASDM::getVersion() const {
5781 :
5782 0 : return version;
5783 : }
5784 :
5785 : /**
5786 : * Set version with the specified int.
5787 : * @param version The int value to which version is to be set.
5788 :
5789 :
5790 :
5791 : */
5792 0 : void ASDM::setVersion (int version) {
5793 :
5794 :
5795 0 : if (hasBeenAdded) {
5796 :
5797 : }
5798 :
5799 0 : this->version = version;
5800 :
5801 0 : }
5802 :
5803 :
5804 :
5805 :
5806 :
5807 :
5808 : /**
5809 : * Get xmlnsPrefix.
5810 : * @return xmlnsPrefix as std::string
5811 : */
5812 0 : std::string ASDM::getXmlnsPrefix() const {
5813 :
5814 0 : return xmlnsPrefix;
5815 : }
5816 :
5817 : /**
5818 : * Set xmlnsPrefix with the specified std::string.
5819 : * @param xmlnsPrefix The std::string value to which xmlnsPrefix is to be set.
5820 :
5821 :
5822 :
5823 : */
5824 0 : void ASDM::setXmlnsPrefix (std::string xmlnsPrefix) {
5825 :
5826 :
5827 0 : if (hasBeenAdded) {
5828 :
5829 : }
5830 :
5831 0 : this->xmlnsPrefix = xmlnsPrefix;
5832 :
5833 0 : }
5834 :
5835 :
5836 :
5837 :
5838 0 : void ASDM::error() {
5839 0 : throw ConversionException("Invalid xml document","ASDM");
5840 : }
5841 :
5842 0 : string ASDM::getXMLEntity(EntityId /* id */) {
5843 0 : throw ConversionException("Not implemented","ASDM");
5844 : }
5845 :
5846 0 : void ASDM::putXMLEntity(string /* xml */) {
5847 0 : throw ConversionException("Not implemented","ASDM");
5848 : }
5849 :
5850 : } // End namespace asdm
5851 :
|
