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 WeatherRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/WeatherRow.h>
39 : #include <alma/ASDM/WeatherTable.h>
40 :
41 : #include <alma/ASDM/StationTable.h>
42 : #include <alma/ASDM/StationRow.h>
43 :
44 :
45 : using asdm::ASDM;
46 : using asdm::WeatherRow;
47 : using asdm::WeatherTable;
48 :
49 : using asdm::StationTable;
50 : using asdm::StationRow;
51 :
52 :
53 : #include <alma/ASDM/Parser.h>
54 :
55 : #include <alma/ASDM/EnumerationParser.h>
56 : #include <alma/ASDM/ASDMValuesParser.h>
57 :
58 : #include <alma/ASDM/InvalidArgumentException.h>
59 :
60 : using namespace std;
61 :
62 : namespace asdm {
63 30910 : WeatherRow::~WeatherRow() {
64 30910 : }
65 :
66 : /**
67 : * Return the table to which this row belongs.
68 : */
69 0 : WeatherTable &WeatherRow::getTable() const {
70 0 : return table;
71 : }
72 :
73 0 : bool WeatherRow::isAdded() const {
74 0 : return hasBeenAdded;
75 : }
76 :
77 15455 : void WeatherRow::isAdded(bool added) {
78 15455 : hasBeenAdded = added;
79 15455 : }
80 :
81 : #ifndef WITHOUT_ACS
82 : using asdmIDL::WeatherRowIDL;
83 : #endif
84 :
85 : #ifndef WITHOUT_ACS
86 : /**
87 : * Return this row in the form of an IDL struct.
88 : * @return The values of this row as a WeatherRowIDL struct.
89 : */
90 : WeatherRowIDL *WeatherRow::toIDL() const {
91 : WeatherRowIDL *x = new WeatherRowIDL ();
92 :
93 : // Fill the IDL structure.
94 :
95 :
96 :
97 :
98 :
99 :
100 :
101 : x->timeInterval = timeInterval.toIDLArrayTimeInterval();
102 :
103 :
104 :
105 :
106 :
107 :
108 :
109 : x->pressureExists = pressureExists;
110 :
111 :
112 :
113 : x->pressure = pressure.toIDLPressure();
114 :
115 :
116 :
117 :
118 :
119 :
120 :
121 : x->relHumidityExists = relHumidityExists;
122 :
123 :
124 :
125 : x->relHumidity = relHumidity.toIDLHumidity();
126 :
127 :
128 :
129 :
130 :
131 :
132 :
133 : x->temperatureExists = temperatureExists;
134 :
135 :
136 :
137 : x->temperature = temperature.toIDLTemperature();
138 :
139 :
140 :
141 :
142 :
143 :
144 :
145 : x->windDirectionExists = windDirectionExists;
146 :
147 :
148 :
149 : x->windDirection = windDirection.toIDLAngle();
150 :
151 :
152 :
153 :
154 :
155 :
156 :
157 : x->windSpeedExists = windSpeedExists;
158 :
159 :
160 :
161 : x->windSpeed = windSpeed.toIDLSpeed();
162 :
163 :
164 :
165 :
166 :
167 :
168 :
169 : x->windMaxExists = windMaxExists;
170 :
171 :
172 :
173 : x->windMax = windMax.toIDLSpeed();
174 :
175 :
176 :
177 :
178 :
179 :
180 :
181 : x->dewPointExists = dewPointExists;
182 :
183 :
184 :
185 : x->dewPoint = dewPoint.toIDLTemperature();
186 :
187 :
188 :
189 :
190 :
191 :
192 :
193 : x->numLayerExists = numLayerExists;
194 :
195 :
196 :
197 :
198 : x->numLayer = numLayer;
199 :
200 :
201 :
202 :
203 :
204 :
205 :
206 :
207 : x->layerHeightExists = layerHeightExists;
208 :
209 :
210 :
211 : x->layerHeight.length(layerHeight.size());
212 : for (unsigned int i = 0; i < layerHeight.size(); ++i) {
213 :
214 : x->layerHeight[i] = layerHeight.at(i).toIDLLength();
215 :
216 : }
217 :
218 :
219 :
220 :
221 :
222 :
223 :
224 : x->temperatureProfileExists = temperatureProfileExists;
225 :
226 :
227 :
228 : x->temperatureProfile.length(temperatureProfile.size());
229 : for (unsigned int i = 0; i < temperatureProfile.size(); ++i) {
230 :
231 : x->temperatureProfile[i] = temperatureProfile.at(i).toIDLTemperature();
232 :
233 : }
234 :
235 :
236 :
237 :
238 :
239 :
240 :
241 : x->cloudMonitorExists = cloudMonitorExists;
242 :
243 :
244 :
245 : x->cloudMonitor = cloudMonitor.toIDLTemperature();
246 :
247 :
248 :
249 :
250 :
251 :
252 :
253 : x->numWVRExists = numWVRExists;
254 :
255 :
256 :
257 :
258 : x->numWVR = numWVR;
259 :
260 :
261 :
262 :
263 :
264 :
265 :
266 :
267 : x->wvrTempExists = wvrTempExists;
268 :
269 :
270 :
271 : x->wvrTemp.length(wvrTemp.size());
272 : for (unsigned int i = 0; i < wvrTemp.size(); ++i) {
273 :
274 : x->wvrTemp[i] = wvrTemp.at(i).toIDLTemperature();
275 :
276 : }
277 :
278 :
279 :
280 :
281 :
282 :
283 :
284 : x->waterExists = waterExists;
285 :
286 :
287 :
288 :
289 : x->water = water;
290 :
291 :
292 :
293 :
294 :
295 :
296 :
297 :
298 :
299 :
300 :
301 :
302 :
303 :
304 : x->stationId = stationId.toIDLTag();
305 :
306 :
307 :
308 :
309 :
310 :
311 :
312 :
313 :
314 : return x;
315 :
316 : }
317 :
318 : void WeatherRow::toIDL(asdmIDL::WeatherRowIDL& x) const {
319 : // Set the x's fields.
320 :
321 :
322 :
323 :
324 :
325 :
326 :
327 : x.timeInterval = timeInterval.toIDLArrayTimeInterval();
328 :
329 :
330 :
331 :
332 :
333 :
334 :
335 : x.pressureExists = pressureExists;
336 :
337 :
338 :
339 : x.pressure = pressure.toIDLPressure();
340 :
341 :
342 :
343 :
344 :
345 :
346 :
347 : x.relHumidityExists = relHumidityExists;
348 :
349 :
350 :
351 : x.relHumidity = relHumidity.toIDLHumidity();
352 :
353 :
354 :
355 :
356 :
357 :
358 :
359 : x.temperatureExists = temperatureExists;
360 :
361 :
362 :
363 : x.temperature = temperature.toIDLTemperature();
364 :
365 :
366 :
367 :
368 :
369 :
370 :
371 : x.windDirectionExists = windDirectionExists;
372 :
373 :
374 :
375 : x.windDirection = windDirection.toIDLAngle();
376 :
377 :
378 :
379 :
380 :
381 :
382 :
383 : x.windSpeedExists = windSpeedExists;
384 :
385 :
386 :
387 : x.windSpeed = windSpeed.toIDLSpeed();
388 :
389 :
390 :
391 :
392 :
393 :
394 :
395 : x.windMaxExists = windMaxExists;
396 :
397 :
398 :
399 : x.windMax = windMax.toIDLSpeed();
400 :
401 :
402 :
403 :
404 :
405 :
406 :
407 : x.dewPointExists = dewPointExists;
408 :
409 :
410 :
411 : x.dewPoint = dewPoint.toIDLTemperature();
412 :
413 :
414 :
415 :
416 :
417 :
418 :
419 : x.numLayerExists = numLayerExists;
420 :
421 :
422 :
423 :
424 : x.numLayer = numLayer;
425 :
426 :
427 :
428 :
429 :
430 :
431 :
432 :
433 : x.layerHeightExists = layerHeightExists;
434 :
435 :
436 :
437 : x.layerHeight.length(layerHeight.size());
438 : for (unsigned int i = 0; i < layerHeight.size(); ++i) {
439 :
440 : x.layerHeight[i] = layerHeight.at(i).toIDLLength();
441 :
442 : }
443 :
444 :
445 :
446 :
447 :
448 :
449 :
450 : x.temperatureProfileExists = temperatureProfileExists;
451 :
452 :
453 :
454 : x.temperatureProfile.length(temperatureProfile.size());
455 : for (unsigned int i = 0; i < temperatureProfile.size(); ++i) {
456 :
457 : x.temperatureProfile[i] = temperatureProfile.at(i).toIDLTemperature();
458 :
459 : }
460 :
461 :
462 :
463 :
464 :
465 :
466 :
467 : x.cloudMonitorExists = cloudMonitorExists;
468 :
469 :
470 :
471 : x.cloudMonitor = cloudMonitor.toIDLTemperature();
472 :
473 :
474 :
475 :
476 :
477 :
478 :
479 : x.numWVRExists = numWVRExists;
480 :
481 :
482 :
483 :
484 : x.numWVR = numWVR;
485 :
486 :
487 :
488 :
489 :
490 :
491 :
492 :
493 : x.wvrTempExists = wvrTempExists;
494 :
495 :
496 :
497 : x.wvrTemp.length(wvrTemp.size());
498 : for (unsigned int i = 0; i < wvrTemp.size(); ++i) {
499 :
500 : x.wvrTemp[i] = wvrTemp.at(i).toIDLTemperature();
501 :
502 : }
503 :
504 :
505 :
506 :
507 :
508 :
509 :
510 : x.waterExists = waterExists;
511 :
512 :
513 :
514 :
515 : x.water = water;
516 :
517 :
518 :
519 :
520 :
521 :
522 :
523 :
524 :
525 :
526 :
527 :
528 :
529 :
530 : x.stationId = stationId.toIDLTag();
531 :
532 :
533 :
534 :
535 :
536 :
537 :
538 :
539 :
540 : }
541 : #endif
542 :
543 :
544 : #ifndef WITHOUT_ACS
545 : /**
546 : * Fill the values of this row from the IDL struct WeatherRowIDL.
547 : * @param x The IDL struct containing the values used to fill this row.
548 : */
549 : void WeatherRow::setFromIDL (WeatherRowIDL x){
550 : try {
551 : // Fill the values from x.
552 :
553 :
554 :
555 :
556 :
557 :
558 : setTimeInterval(ArrayTimeInterval (x.timeInterval));
559 :
560 :
561 :
562 :
563 :
564 :
565 :
566 : pressureExists = x.pressureExists;
567 : if (x.pressureExists) {
568 :
569 :
570 :
571 : setPressure(Pressure (x.pressure));
572 :
573 :
574 :
575 : }
576 :
577 :
578 :
579 :
580 :
581 : relHumidityExists = x.relHumidityExists;
582 : if (x.relHumidityExists) {
583 :
584 :
585 :
586 : setRelHumidity(Humidity (x.relHumidity));
587 :
588 :
589 :
590 : }
591 :
592 :
593 :
594 :
595 :
596 : temperatureExists = x.temperatureExists;
597 : if (x.temperatureExists) {
598 :
599 :
600 :
601 : setTemperature(Temperature (x.temperature));
602 :
603 :
604 :
605 : }
606 :
607 :
608 :
609 :
610 :
611 : windDirectionExists = x.windDirectionExists;
612 : if (x.windDirectionExists) {
613 :
614 :
615 :
616 : setWindDirection(Angle (x.windDirection));
617 :
618 :
619 :
620 : }
621 :
622 :
623 :
624 :
625 :
626 : windSpeedExists = x.windSpeedExists;
627 : if (x.windSpeedExists) {
628 :
629 :
630 :
631 : setWindSpeed(Speed (x.windSpeed));
632 :
633 :
634 :
635 : }
636 :
637 :
638 :
639 :
640 :
641 : windMaxExists = x.windMaxExists;
642 : if (x.windMaxExists) {
643 :
644 :
645 :
646 : setWindMax(Speed (x.windMax));
647 :
648 :
649 :
650 : }
651 :
652 :
653 :
654 :
655 :
656 : dewPointExists = x.dewPointExists;
657 : if (x.dewPointExists) {
658 :
659 :
660 :
661 : setDewPoint(Temperature (x.dewPoint));
662 :
663 :
664 :
665 : }
666 :
667 :
668 :
669 :
670 :
671 : numLayerExists = x.numLayerExists;
672 : if (x.numLayerExists) {
673 :
674 :
675 :
676 : setNumLayer(x.numLayer);
677 :
678 :
679 :
680 : }
681 :
682 :
683 :
684 :
685 :
686 : layerHeightExists = x.layerHeightExists;
687 : if (x.layerHeightExists) {
688 :
689 :
690 :
691 : layerHeight .clear();
692 : for (unsigned int i = 0; i <x.layerHeight.length(); ++i) {
693 :
694 : layerHeight.push_back(Length (x.layerHeight[i]));
695 :
696 : }
697 :
698 :
699 :
700 : }
701 :
702 :
703 :
704 :
705 :
706 : temperatureProfileExists = x.temperatureProfileExists;
707 : if (x.temperatureProfileExists) {
708 :
709 :
710 :
711 : temperatureProfile .clear();
712 : for (unsigned int i = 0; i <x.temperatureProfile.length(); ++i) {
713 :
714 : temperatureProfile.push_back(Temperature (x.temperatureProfile[i]));
715 :
716 : }
717 :
718 :
719 :
720 : }
721 :
722 :
723 :
724 :
725 :
726 : cloudMonitorExists = x.cloudMonitorExists;
727 : if (x.cloudMonitorExists) {
728 :
729 :
730 :
731 : setCloudMonitor(Temperature (x.cloudMonitor));
732 :
733 :
734 :
735 : }
736 :
737 :
738 :
739 :
740 :
741 : numWVRExists = x.numWVRExists;
742 : if (x.numWVRExists) {
743 :
744 :
745 :
746 : setNumWVR(x.numWVR);
747 :
748 :
749 :
750 : }
751 :
752 :
753 :
754 :
755 :
756 : wvrTempExists = x.wvrTempExists;
757 : if (x.wvrTempExists) {
758 :
759 :
760 :
761 : wvrTemp .clear();
762 : for (unsigned int i = 0; i <x.wvrTemp.length(); ++i) {
763 :
764 : wvrTemp.push_back(Temperature (x.wvrTemp[i]));
765 :
766 : }
767 :
768 :
769 :
770 : }
771 :
772 :
773 :
774 :
775 :
776 : waterExists = x.waterExists;
777 : if (x.waterExists) {
778 :
779 :
780 :
781 : setWater(x.water);
782 :
783 :
784 :
785 : }
786 :
787 :
788 :
789 :
790 :
791 :
792 :
793 :
794 :
795 :
796 : setStationId(Tag (x.stationId));
797 :
798 :
799 :
800 :
801 :
802 :
803 :
804 :
805 :
806 : } catch (const IllegalAccessException &err) {
807 : throw ConversionException (err.getMessage(),"Weather");
808 : }
809 : }
810 : #endif
811 :
812 : /**
813 : * Return this row in the form of an XML string.
814 : * @return The values of this row as an XML string.
815 : */
816 0 : string WeatherRow::toXML() const {
817 0 : string buf;
818 0 : buf.append("<row> \n");
819 :
820 :
821 :
822 :
823 :
824 :
825 0 : Parser::toXML(timeInterval, "timeInterval", buf);
826 :
827 :
828 :
829 :
830 :
831 :
832 0 : if (pressureExists) {
833 :
834 :
835 0 : Parser::toXML(pressure, "pressure", buf);
836 :
837 :
838 : }
839 :
840 :
841 :
842 :
843 :
844 0 : if (relHumidityExists) {
845 :
846 :
847 0 : Parser::toXML(relHumidity, "relHumidity", buf);
848 :
849 :
850 : }
851 :
852 :
853 :
854 :
855 :
856 0 : if (temperatureExists) {
857 :
858 :
859 0 : Parser::toXML(temperature, "temperature", buf);
860 :
861 :
862 : }
863 :
864 :
865 :
866 :
867 :
868 0 : if (windDirectionExists) {
869 :
870 :
871 0 : Parser::toXML(windDirection, "windDirection", buf);
872 :
873 :
874 : }
875 :
876 :
877 :
878 :
879 :
880 0 : if (windSpeedExists) {
881 :
882 :
883 0 : Parser::toXML(windSpeed, "windSpeed", buf);
884 :
885 :
886 : }
887 :
888 :
889 :
890 :
891 :
892 0 : if (windMaxExists) {
893 :
894 :
895 0 : Parser::toXML(windMax, "windMax", buf);
896 :
897 :
898 : }
899 :
900 :
901 :
902 :
903 :
904 0 : if (dewPointExists) {
905 :
906 :
907 0 : Parser::toXML(dewPoint, "dewPoint", buf);
908 :
909 :
910 : }
911 :
912 :
913 :
914 :
915 :
916 0 : if (numLayerExists) {
917 :
918 :
919 0 : Parser::toXML(numLayer, "numLayer", buf);
920 :
921 :
922 : }
923 :
924 :
925 :
926 :
927 :
928 0 : if (layerHeightExists) {
929 :
930 :
931 0 : Parser::toXML(layerHeight, "layerHeight", buf);
932 :
933 :
934 : }
935 :
936 :
937 :
938 :
939 :
940 0 : if (temperatureProfileExists) {
941 :
942 :
943 0 : Parser::toXML(temperatureProfile, "temperatureProfile", buf);
944 :
945 :
946 : }
947 :
948 :
949 :
950 :
951 :
952 0 : if (cloudMonitorExists) {
953 :
954 :
955 0 : Parser::toXML(cloudMonitor, "cloudMonitor", buf);
956 :
957 :
958 : }
959 :
960 :
961 :
962 :
963 :
964 0 : if (numWVRExists) {
965 :
966 :
967 0 : Parser::toXML(numWVR, "numWVR", buf);
968 :
969 :
970 : }
971 :
972 :
973 :
974 :
975 :
976 0 : if (wvrTempExists) {
977 :
978 :
979 0 : Parser::toXML(wvrTemp, "wvrTemp", buf);
980 :
981 :
982 : }
983 :
984 :
985 :
986 :
987 :
988 0 : if (waterExists) {
989 :
990 :
991 0 : Parser::toXML(water, "water", buf);
992 :
993 :
994 : }
995 :
996 :
997 :
998 :
999 :
1000 :
1001 :
1002 :
1003 :
1004 0 : Parser::toXML(stationId, "stationId", buf);
1005 :
1006 :
1007 :
1008 :
1009 :
1010 :
1011 :
1012 :
1013 :
1014 0 : buf.append("</row>\n");
1015 0 : return buf;
1016 0 : }
1017 :
1018 : /**
1019 : * Fill the values of this row from an XML string
1020 : * that was produced by the toXML() method.
1021 : * @param x The XML string being used to set the values of this row.
1022 : */
1023 15455 : void WeatherRow::setFromXML (string rowDoc) {
1024 15455 : Parser row(rowDoc);
1025 15455 : string s = "";
1026 : try {
1027 :
1028 :
1029 :
1030 :
1031 :
1032 15455 : setTimeInterval(Parser::getArrayTimeInterval("timeInterval","Weather",rowDoc));
1033 :
1034 :
1035 :
1036 :
1037 :
1038 :
1039 15455 : if (row.isStr("<pressure>")) {
1040 :
1041 15455 : setPressure(Parser::getPressure("pressure","Weather",rowDoc));
1042 :
1043 : }
1044 :
1045 :
1046 :
1047 :
1048 :
1049 15455 : if (row.isStr("<relHumidity>")) {
1050 :
1051 15455 : setRelHumidity(Parser::getHumidity("relHumidity","Weather",rowDoc));
1052 :
1053 : }
1054 :
1055 :
1056 :
1057 :
1058 :
1059 15455 : if (row.isStr("<temperature>")) {
1060 :
1061 15455 : setTemperature(Parser::getTemperature("temperature","Weather",rowDoc));
1062 :
1063 : }
1064 :
1065 :
1066 :
1067 :
1068 :
1069 15455 : if (row.isStr("<windDirection>")) {
1070 :
1071 15455 : setWindDirection(Parser::getAngle("windDirection","Weather",rowDoc));
1072 :
1073 : }
1074 :
1075 :
1076 :
1077 :
1078 :
1079 15455 : if (row.isStr("<windSpeed>")) {
1080 :
1081 15455 : setWindSpeed(Parser::getSpeed("windSpeed","Weather",rowDoc));
1082 :
1083 : }
1084 :
1085 :
1086 :
1087 :
1088 :
1089 15455 : if (row.isStr("<windMax>")) {
1090 :
1091 15455 : setWindMax(Parser::getSpeed("windMax","Weather",rowDoc));
1092 :
1093 : }
1094 :
1095 :
1096 :
1097 :
1098 :
1099 15455 : if (row.isStr("<dewPoint>")) {
1100 :
1101 416 : setDewPoint(Parser::getTemperature("dewPoint","Weather",rowDoc));
1102 :
1103 : }
1104 :
1105 :
1106 :
1107 :
1108 :
1109 15455 : if (row.isStr("<numLayer>")) {
1110 :
1111 0 : setNumLayer(Parser::getInteger("numLayer","Weather",rowDoc));
1112 :
1113 : }
1114 :
1115 :
1116 :
1117 :
1118 :
1119 15455 : if (row.isStr("<layerHeight>")) {
1120 :
1121 :
1122 0 : setLayerHeight(Parser::get1DLength("layerHeight","Weather",rowDoc));
1123 :
1124 :
1125 : }
1126 :
1127 :
1128 :
1129 :
1130 :
1131 15455 : if (row.isStr("<temperatureProfile>")) {
1132 :
1133 :
1134 0 : setTemperatureProfile(Parser::get1DTemperature("temperatureProfile","Weather",rowDoc));
1135 :
1136 :
1137 : }
1138 :
1139 :
1140 :
1141 :
1142 :
1143 15455 : if (row.isStr("<cloudMonitor>")) {
1144 :
1145 0 : setCloudMonitor(Parser::getTemperature("cloudMonitor","Weather",rowDoc));
1146 :
1147 : }
1148 :
1149 :
1150 :
1151 :
1152 :
1153 15455 : if (row.isStr("<numWVR>")) {
1154 :
1155 0 : setNumWVR(Parser::getInteger("numWVR","Weather",rowDoc));
1156 :
1157 : }
1158 :
1159 :
1160 :
1161 :
1162 :
1163 15455 : if (row.isStr("<wvrTemp>")) {
1164 :
1165 :
1166 0 : setWvrTemp(Parser::get1DTemperature("wvrTemp","Weather",rowDoc));
1167 :
1168 :
1169 : }
1170 :
1171 :
1172 :
1173 :
1174 :
1175 15455 : if (row.isStr("<water>")) {
1176 :
1177 0 : setWater(Parser::getDouble("water","Weather",rowDoc));
1178 :
1179 : }
1180 :
1181 :
1182 :
1183 :
1184 :
1185 :
1186 :
1187 :
1188 :
1189 15455 : setStationId(Parser::getTag("stationId","Station",rowDoc));
1190 :
1191 :
1192 :
1193 :
1194 :
1195 :
1196 :
1197 :
1198 0 : } catch (const IllegalAccessException &err) {
1199 0 : throw ConversionException (err.getMessage(),"Weather");
1200 0 : }
1201 15455 : }
1202 :
1203 0 : void WeatherRow::toBin(EndianOSStream& eoss) {
1204 :
1205 :
1206 :
1207 :
1208 :
1209 0 : stationId.toBin(eoss);
1210 :
1211 :
1212 :
1213 :
1214 :
1215 :
1216 0 : timeInterval.toBin(eoss);
1217 :
1218 :
1219 :
1220 :
1221 :
1222 :
1223 0 : eoss.writeBoolean(pressureExists);
1224 0 : if (pressureExists) {
1225 :
1226 :
1227 :
1228 :
1229 0 : pressure.toBin(eoss);
1230 :
1231 :
1232 :
1233 : }
1234 :
1235 0 : eoss.writeBoolean(relHumidityExists);
1236 0 : if (relHumidityExists) {
1237 :
1238 :
1239 :
1240 :
1241 0 : relHumidity.toBin(eoss);
1242 :
1243 :
1244 :
1245 : }
1246 :
1247 0 : eoss.writeBoolean(temperatureExists);
1248 0 : if (temperatureExists) {
1249 :
1250 :
1251 :
1252 :
1253 0 : temperature.toBin(eoss);
1254 :
1255 :
1256 :
1257 : }
1258 :
1259 0 : eoss.writeBoolean(windDirectionExists);
1260 0 : if (windDirectionExists) {
1261 :
1262 :
1263 :
1264 :
1265 0 : windDirection.toBin(eoss);
1266 :
1267 :
1268 :
1269 : }
1270 :
1271 0 : eoss.writeBoolean(windSpeedExists);
1272 0 : if (windSpeedExists) {
1273 :
1274 :
1275 :
1276 :
1277 0 : windSpeed.toBin(eoss);
1278 :
1279 :
1280 :
1281 : }
1282 :
1283 0 : eoss.writeBoolean(windMaxExists);
1284 0 : if (windMaxExists) {
1285 :
1286 :
1287 :
1288 :
1289 0 : windMax.toBin(eoss);
1290 :
1291 :
1292 :
1293 : }
1294 :
1295 0 : eoss.writeBoolean(dewPointExists);
1296 0 : if (dewPointExists) {
1297 :
1298 :
1299 :
1300 :
1301 0 : dewPoint.toBin(eoss);
1302 :
1303 :
1304 :
1305 : }
1306 :
1307 0 : eoss.writeBoolean(numLayerExists);
1308 0 : if (numLayerExists) {
1309 :
1310 :
1311 :
1312 :
1313 :
1314 0 : eoss.writeInt(numLayer);
1315 :
1316 :
1317 :
1318 :
1319 : }
1320 :
1321 0 : eoss.writeBoolean(layerHeightExists);
1322 0 : if (layerHeightExists) {
1323 :
1324 :
1325 :
1326 :
1327 0 : Length::toBin(layerHeight, eoss);
1328 :
1329 :
1330 :
1331 : }
1332 :
1333 0 : eoss.writeBoolean(temperatureProfileExists);
1334 0 : if (temperatureProfileExists) {
1335 :
1336 :
1337 :
1338 :
1339 0 : Temperature::toBin(temperatureProfile, eoss);
1340 :
1341 :
1342 :
1343 : }
1344 :
1345 0 : eoss.writeBoolean(cloudMonitorExists);
1346 0 : if (cloudMonitorExists) {
1347 :
1348 :
1349 :
1350 :
1351 0 : cloudMonitor.toBin(eoss);
1352 :
1353 :
1354 :
1355 : }
1356 :
1357 0 : eoss.writeBoolean(numWVRExists);
1358 0 : if (numWVRExists) {
1359 :
1360 :
1361 :
1362 :
1363 :
1364 0 : eoss.writeInt(numWVR);
1365 :
1366 :
1367 :
1368 :
1369 : }
1370 :
1371 0 : eoss.writeBoolean(wvrTempExists);
1372 0 : if (wvrTempExists) {
1373 :
1374 :
1375 :
1376 :
1377 0 : Temperature::toBin(wvrTemp, eoss);
1378 :
1379 :
1380 :
1381 : }
1382 :
1383 0 : eoss.writeBoolean(waterExists);
1384 0 : if (waterExists) {
1385 :
1386 :
1387 :
1388 :
1389 :
1390 0 : eoss.writeDouble(water);
1391 :
1392 :
1393 :
1394 :
1395 : }
1396 :
1397 0 : }
1398 :
1399 0 : void WeatherRow::stationIdFromBin(EndianIStream& eis) {
1400 :
1401 :
1402 :
1403 :
1404 0 : stationId = Tag::fromBin(eis);
1405 :
1406 :
1407 :
1408 0 : }
1409 0 : void WeatherRow::timeIntervalFromBin(EndianIStream& eis) {
1410 :
1411 :
1412 :
1413 :
1414 0 : timeInterval = ArrayTimeInterval::fromBin(eis);
1415 :
1416 :
1417 :
1418 0 : }
1419 :
1420 0 : void WeatherRow::pressureFromBin(EndianIStream& eis) {
1421 :
1422 0 : pressureExists = eis.readBoolean();
1423 0 : if (pressureExists) {
1424 :
1425 :
1426 :
1427 :
1428 0 : pressure = Pressure::fromBin(eis);
1429 :
1430 :
1431 :
1432 : }
1433 :
1434 0 : }
1435 0 : void WeatherRow::relHumidityFromBin(EndianIStream& eis) {
1436 :
1437 0 : relHumidityExists = eis.readBoolean();
1438 0 : if (relHumidityExists) {
1439 :
1440 :
1441 :
1442 :
1443 0 : relHumidity = Humidity::fromBin(eis);
1444 :
1445 :
1446 :
1447 : }
1448 :
1449 0 : }
1450 0 : void WeatherRow::temperatureFromBin(EndianIStream& eis) {
1451 :
1452 0 : temperatureExists = eis.readBoolean();
1453 0 : if (temperatureExists) {
1454 :
1455 :
1456 :
1457 :
1458 0 : temperature = Temperature::fromBin(eis);
1459 :
1460 :
1461 :
1462 : }
1463 :
1464 0 : }
1465 0 : void WeatherRow::windDirectionFromBin(EndianIStream& eis) {
1466 :
1467 0 : windDirectionExists = eis.readBoolean();
1468 0 : if (windDirectionExists) {
1469 :
1470 :
1471 :
1472 :
1473 0 : windDirection = Angle::fromBin(eis);
1474 :
1475 :
1476 :
1477 : }
1478 :
1479 0 : }
1480 0 : void WeatherRow::windSpeedFromBin(EndianIStream& eis) {
1481 :
1482 0 : windSpeedExists = eis.readBoolean();
1483 0 : if (windSpeedExists) {
1484 :
1485 :
1486 :
1487 :
1488 0 : windSpeed = Speed::fromBin(eis);
1489 :
1490 :
1491 :
1492 : }
1493 :
1494 0 : }
1495 0 : void WeatherRow::windMaxFromBin(EndianIStream& eis) {
1496 :
1497 0 : windMaxExists = eis.readBoolean();
1498 0 : if (windMaxExists) {
1499 :
1500 :
1501 :
1502 :
1503 0 : windMax = Speed::fromBin(eis);
1504 :
1505 :
1506 :
1507 : }
1508 :
1509 0 : }
1510 0 : void WeatherRow::dewPointFromBin(EndianIStream& eis) {
1511 :
1512 0 : dewPointExists = eis.readBoolean();
1513 0 : if (dewPointExists) {
1514 :
1515 :
1516 :
1517 :
1518 0 : dewPoint = Temperature::fromBin(eis);
1519 :
1520 :
1521 :
1522 : }
1523 :
1524 0 : }
1525 0 : void WeatherRow::numLayerFromBin(EndianIStream& eis) {
1526 :
1527 0 : numLayerExists = eis.readBoolean();
1528 0 : if (numLayerExists) {
1529 :
1530 :
1531 :
1532 :
1533 :
1534 0 : numLayer = eis.readInt();
1535 :
1536 :
1537 :
1538 :
1539 : }
1540 :
1541 0 : }
1542 0 : void WeatherRow::layerHeightFromBin(EndianIStream& eis) {
1543 :
1544 0 : layerHeightExists = eis.readBoolean();
1545 0 : if (layerHeightExists) {
1546 :
1547 :
1548 :
1549 :
1550 :
1551 :
1552 0 : layerHeight = Length::from1DBin(eis);
1553 :
1554 :
1555 :
1556 :
1557 :
1558 : }
1559 :
1560 0 : }
1561 0 : void WeatherRow::temperatureProfileFromBin(EndianIStream& eis) {
1562 :
1563 0 : temperatureProfileExists = eis.readBoolean();
1564 0 : if (temperatureProfileExists) {
1565 :
1566 :
1567 :
1568 :
1569 :
1570 :
1571 0 : temperatureProfile = Temperature::from1DBin(eis);
1572 :
1573 :
1574 :
1575 :
1576 :
1577 : }
1578 :
1579 0 : }
1580 0 : void WeatherRow::cloudMonitorFromBin(EndianIStream& eis) {
1581 :
1582 0 : cloudMonitorExists = eis.readBoolean();
1583 0 : if (cloudMonitorExists) {
1584 :
1585 :
1586 :
1587 :
1588 0 : cloudMonitor = Temperature::fromBin(eis);
1589 :
1590 :
1591 :
1592 : }
1593 :
1594 0 : }
1595 0 : void WeatherRow::numWVRFromBin(EndianIStream& eis) {
1596 :
1597 0 : numWVRExists = eis.readBoolean();
1598 0 : if (numWVRExists) {
1599 :
1600 :
1601 :
1602 :
1603 :
1604 0 : numWVR = eis.readInt();
1605 :
1606 :
1607 :
1608 :
1609 : }
1610 :
1611 0 : }
1612 0 : void WeatherRow::wvrTempFromBin(EndianIStream& eis) {
1613 :
1614 0 : wvrTempExists = eis.readBoolean();
1615 0 : if (wvrTempExists) {
1616 :
1617 :
1618 :
1619 :
1620 :
1621 :
1622 0 : wvrTemp = Temperature::from1DBin(eis);
1623 :
1624 :
1625 :
1626 :
1627 :
1628 : }
1629 :
1630 0 : }
1631 0 : void WeatherRow::waterFromBin(EndianIStream& eis) {
1632 :
1633 0 : waterExists = eis.readBoolean();
1634 0 : if (waterExists) {
1635 :
1636 :
1637 :
1638 :
1639 :
1640 0 : water = eis.readDouble();
1641 :
1642 :
1643 :
1644 :
1645 : }
1646 :
1647 0 : }
1648 :
1649 :
1650 0 : WeatherRow* WeatherRow::fromBin(EndianIStream& eis, WeatherTable& table, const vector<string>& attributesSeq) {
1651 0 : WeatherRow* row = new WeatherRow(table);
1652 :
1653 0 : map<string, WeatherAttributeFromBin>::iterator iter ;
1654 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
1655 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
1656 0 : if (iter != row->fromBinMethods.end()) {
1657 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
1658 : }
1659 : else {
1660 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
1661 0 : if (functorP)
1662 0 : (*functorP)(eis);
1663 : else
1664 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "WeatherTable");
1665 : }
1666 :
1667 : }
1668 0 : return row;
1669 : }
1670 :
1671 : //
1672 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
1673 : // of one row.
1674 : //
1675 :
1676 : // Convert a string into an Tag
1677 0 : void WeatherRow::stationIdFromText(const string & s) {
1678 :
1679 :
1680 0 : stationId = ASDMValuesParser::parse<Tag>(s);
1681 :
1682 :
1683 0 : }
1684 :
1685 :
1686 : // Convert a string into an ArrayTimeInterval
1687 0 : void WeatherRow::timeIntervalFromText(const string & s) {
1688 :
1689 :
1690 0 : timeInterval = ASDMValuesParser::parse<ArrayTimeInterval>(s);
1691 :
1692 :
1693 0 : }
1694 :
1695 :
1696 :
1697 : // Convert a string into an Pressure
1698 0 : void WeatherRow::pressureFromText(const string & s) {
1699 0 : pressureExists = true;
1700 :
1701 :
1702 0 : pressure = ASDMValuesParser::parse<Pressure>(s);
1703 :
1704 :
1705 0 : }
1706 :
1707 :
1708 : // Convert a string into an Humidity
1709 0 : void WeatherRow::relHumidityFromText(const string & s) {
1710 0 : relHumidityExists = true;
1711 :
1712 :
1713 0 : relHumidity = ASDMValuesParser::parse<Humidity>(s);
1714 :
1715 :
1716 0 : }
1717 :
1718 :
1719 : // Convert a string into an Temperature
1720 0 : void WeatherRow::temperatureFromText(const string & s) {
1721 0 : temperatureExists = true;
1722 :
1723 :
1724 0 : temperature = ASDMValuesParser::parse<Temperature>(s);
1725 :
1726 :
1727 0 : }
1728 :
1729 :
1730 : // Convert a string into an Angle
1731 0 : void WeatherRow::windDirectionFromText(const string & s) {
1732 0 : windDirectionExists = true;
1733 :
1734 :
1735 0 : windDirection = ASDMValuesParser::parse<Angle>(s);
1736 :
1737 :
1738 0 : }
1739 :
1740 :
1741 : // Convert a string into an Speed
1742 0 : void WeatherRow::windSpeedFromText(const string & s) {
1743 0 : windSpeedExists = true;
1744 :
1745 :
1746 0 : windSpeed = ASDMValuesParser::parse<Speed>(s);
1747 :
1748 :
1749 0 : }
1750 :
1751 :
1752 : // Convert a string into an Speed
1753 0 : void WeatherRow::windMaxFromText(const string & s) {
1754 0 : windMaxExists = true;
1755 :
1756 :
1757 0 : windMax = ASDMValuesParser::parse<Speed>(s);
1758 :
1759 :
1760 0 : }
1761 :
1762 :
1763 : // Convert a string into an Temperature
1764 0 : void WeatherRow::dewPointFromText(const string & s) {
1765 0 : dewPointExists = true;
1766 :
1767 :
1768 0 : dewPoint = ASDMValuesParser::parse<Temperature>(s);
1769 :
1770 :
1771 0 : }
1772 :
1773 :
1774 : // Convert a string into an int
1775 0 : void WeatherRow::numLayerFromText(const string & s) {
1776 0 : numLayerExists = true;
1777 :
1778 :
1779 0 : numLayer = ASDMValuesParser::parse<int>(s);
1780 :
1781 :
1782 0 : }
1783 :
1784 :
1785 : // Convert a string into an Length
1786 0 : void WeatherRow::layerHeightFromText(const string & s) {
1787 0 : layerHeightExists = true;
1788 :
1789 :
1790 0 : layerHeight = ASDMValuesParser::parse1D<Length>(s);
1791 :
1792 :
1793 0 : }
1794 :
1795 :
1796 : // Convert a string into an Temperature
1797 0 : void WeatherRow::temperatureProfileFromText(const string & s) {
1798 0 : temperatureProfileExists = true;
1799 :
1800 :
1801 0 : temperatureProfile = ASDMValuesParser::parse1D<Temperature>(s);
1802 :
1803 :
1804 0 : }
1805 :
1806 :
1807 : // Convert a string into an Temperature
1808 0 : void WeatherRow::cloudMonitorFromText(const string & s) {
1809 0 : cloudMonitorExists = true;
1810 :
1811 :
1812 0 : cloudMonitor = ASDMValuesParser::parse<Temperature>(s);
1813 :
1814 :
1815 0 : }
1816 :
1817 :
1818 : // Convert a string into an int
1819 0 : void WeatherRow::numWVRFromText(const string & s) {
1820 0 : numWVRExists = true;
1821 :
1822 :
1823 0 : numWVR = ASDMValuesParser::parse<int>(s);
1824 :
1825 :
1826 0 : }
1827 :
1828 :
1829 : // Convert a string into an Temperature
1830 0 : void WeatherRow::wvrTempFromText(const string & s) {
1831 0 : wvrTempExists = true;
1832 :
1833 :
1834 0 : wvrTemp = ASDMValuesParser::parse1D<Temperature>(s);
1835 :
1836 :
1837 0 : }
1838 :
1839 :
1840 : // Convert a string into an double
1841 0 : void WeatherRow::waterFromText(const string & s) {
1842 0 : waterExists = true;
1843 :
1844 :
1845 0 : water = ASDMValuesParser::parse<double>(s);
1846 :
1847 :
1848 0 : }
1849 :
1850 :
1851 :
1852 0 : void WeatherRow::fromText(const std::string& attributeName, const std::string& t) {
1853 0 : map<string, WeatherAttributeFromText>::iterator iter;
1854 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
1855 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "WeatherTable");
1856 0 : (this->*(iter->second))(t);
1857 0 : }
1858 :
1859 : ////////////////////////////////////////////////
1860 : // Intrinsic Table Attributes getters/setters //
1861 : ////////////////////////////////////////////////
1862 :
1863 :
1864 :
1865 :
1866 : /**
1867 : * Get timeInterval.
1868 : * @return timeInterval as ArrayTimeInterval
1869 : */
1870 157556 : ArrayTimeInterval WeatherRow::getTimeInterval() const {
1871 :
1872 157556 : return timeInterval;
1873 : }
1874 :
1875 : /**
1876 : * Set timeInterval with the specified ArrayTimeInterval.
1877 : * @param timeInterval The ArrayTimeInterval value to which timeInterval is to be set.
1878 :
1879 :
1880 :
1881 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1882 :
1883 : */
1884 15455 : void WeatherRow::setTimeInterval (ArrayTimeInterval timeInterval) {
1885 :
1886 :
1887 15455 : if (hasBeenAdded) {
1888 :
1889 0 : throw IllegalAccessException("timeInterval", "Weather");
1890 :
1891 : }
1892 :
1893 15455 : this->timeInterval = timeInterval;
1894 :
1895 15455 : }
1896 :
1897 :
1898 :
1899 :
1900 : /**
1901 : * The attribute pressure is optional. Return true if this attribute exists.
1902 : * @return true if and only if the pressure attribute exists.
1903 : */
1904 4516 : bool WeatherRow::isPressureExists() const {
1905 4516 : return pressureExists;
1906 : }
1907 :
1908 :
1909 :
1910 : /**
1911 : * Get pressure, which is optional.
1912 : * @return pressure as Pressure
1913 : * @throw IllegalAccessException If pressure does not exist.
1914 : */
1915 4516 : Pressure WeatherRow::getPressure() const {
1916 4516 : if (!pressureExists) {
1917 0 : throw IllegalAccessException("pressure", "Weather");
1918 : }
1919 :
1920 4516 : return pressure;
1921 : }
1922 :
1923 : /**
1924 : * Set pressure with the specified Pressure.
1925 : * @param pressure The Pressure value to which pressure is to be set.
1926 :
1927 :
1928 : */
1929 15455 : void WeatherRow::setPressure (Pressure pressure) {
1930 :
1931 15455 : this->pressure = pressure;
1932 :
1933 15455 : pressureExists = true;
1934 :
1935 15455 : }
1936 :
1937 :
1938 : /**
1939 : * Mark pressure, which is an optional field, as non-existent.
1940 : */
1941 0 : void WeatherRow::clearPressure () {
1942 0 : pressureExists = false;
1943 0 : }
1944 :
1945 :
1946 :
1947 : /**
1948 : * The attribute relHumidity is optional. Return true if this attribute exists.
1949 : * @return true if and only if the relHumidity attribute exists.
1950 : */
1951 4516 : bool WeatherRow::isRelHumidityExists() const {
1952 4516 : return relHumidityExists;
1953 : }
1954 :
1955 :
1956 :
1957 : /**
1958 : * Get relHumidity, which is optional.
1959 : * @return relHumidity as Humidity
1960 : * @throw IllegalAccessException If relHumidity does not exist.
1961 : */
1962 4516 : Humidity WeatherRow::getRelHumidity() const {
1963 4516 : if (!relHumidityExists) {
1964 0 : throw IllegalAccessException("relHumidity", "Weather");
1965 : }
1966 :
1967 4516 : return relHumidity;
1968 : }
1969 :
1970 : /**
1971 : * Set relHumidity with the specified Humidity.
1972 : * @param relHumidity The Humidity value to which relHumidity is to be set.
1973 :
1974 :
1975 : */
1976 15455 : void WeatherRow::setRelHumidity (Humidity relHumidity) {
1977 :
1978 15455 : this->relHumidity = relHumidity;
1979 :
1980 15455 : relHumidityExists = true;
1981 :
1982 15455 : }
1983 :
1984 :
1985 : /**
1986 : * Mark relHumidity, which is an optional field, as non-existent.
1987 : */
1988 0 : void WeatherRow::clearRelHumidity () {
1989 0 : relHumidityExists = false;
1990 0 : }
1991 :
1992 :
1993 :
1994 : /**
1995 : * The attribute temperature is optional. Return true if this attribute exists.
1996 : * @return true if and only if the temperature attribute exists.
1997 : */
1998 4516 : bool WeatherRow::isTemperatureExists() const {
1999 4516 : return temperatureExists;
2000 : }
2001 :
2002 :
2003 :
2004 : /**
2005 : * Get temperature, which is optional.
2006 : * @return temperature as Temperature
2007 : * @throw IllegalAccessException If temperature does not exist.
2008 : */
2009 4516 : Temperature WeatherRow::getTemperature() const {
2010 4516 : if (!temperatureExists) {
2011 0 : throw IllegalAccessException("temperature", "Weather");
2012 : }
2013 :
2014 4516 : return temperature;
2015 : }
2016 :
2017 : /**
2018 : * Set temperature with the specified Temperature.
2019 : * @param temperature The Temperature value to which temperature is to be set.
2020 :
2021 :
2022 : */
2023 15455 : void WeatherRow::setTemperature (Temperature temperature) {
2024 :
2025 15455 : this->temperature = temperature;
2026 :
2027 15455 : temperatureExists = true;
2028 :
2029 15455 : }
2030 :
2031 :
2032 : /**
2033 : * Mark temperature, which is an optional field, as non-existent.
2034 : */
2035 0 : void WeatherRow::clearTemperature () {
2036 0 : temperatureExists = false;
2037 0 : }
2038 :
2039 :
2040 :
2041 : /**
2042 : * The attribute windDirection is optional. Return true if this attribute exists.
2043 : * @return true if and only if the windDirection attribute exists.
2044 : */
2045 4516 : bool WeatherRow::isWindDirectionExists() const {
2046 4516 : return windDirectionExists;
2047 : }
2048 :
2049 :
2050 :
2051 : /**
2052 : * Get windDirection, which is optional.
2053 : * @return windDirection as Angle
2054 : * @throw IllegalAccessException If windDirection does not exist.
2055 : */
2056 4516 : Angle WeatherRow::getWindDirection() const {
2057 4516 : if (!windDirectionExists) {
2058 0 : throw IllegalAccessException("windDirection", "Weather");
2059 : }
2060 :
2061 4516 : return windDirection;
2062 : }
2063 :
2064 : /**
2065 : * Set windDirection with the specified Angle.
2066 : * @param windDirection The Angle value to which windDirection is to be set.
2067 :
2068 :
2069 : */
2070 15455 : void WeatherRow::setWindDirection (Angle windDirection) {
2071 :
2072 15455 : this->windDirection = windDirection;
2073 :
2074 15455 : windDirectionExists = true;
2075 :
2076 15455 : }
2077 :
2078 :
2079 : /**
2080 : * Mark windDirection, which is an optional field, as non-existent.
2081 : */
2082 0 : void WeatherRow::clearWindDirection () {
2083 0 : windDirectionExists = false;
2084 0 : }
2085 :
2086 :
2087 :
2088 : /**
2089 : * The attribute windSpeed is optional. Return true if this attribute exists.
2090 : * @return true if and only if the windSpeed attribute exists.
2091 : */
2092 4516 : bool WeatherRow::isWindSpeedExists() const {
2093 4516 : return windSpeedExists;
2094 : }
2095 :
2096 :
2097 :
2098 : /**
2099 : * Get windSpeed, which is optional.
2100 : * @return windSpeed as Speed
2101 : * @throw IllegalAccessException If windSpeed does not exist.
2102 : */
2103 4516 : Speed WeatherRow::getWindSpeed() const {
2104 4516 : if (!windSpeedExists) {
2105 0 : throw IllegalAccessException("windSpeed", "Weather");
2106 : }
2107 :
2108 4516 : return windSpeed;
2109 : }
2110 :
2111 : /**
2112 : * Set windSpeed with the specified Speed.
2113 : * @param windSpeed The Speed value to which windSpeed is to be set.
2114 :
2115 :
2116 : */
2117 15455 : void WeatherRow::setWindSpeed (Speed windSpeed) {
2118 :
2119 15455 : this->windSpeed = windSpeed;
2120 :
2121 15455 : windSpeedExists = true;
2122 :
2123 15455 : }
2124 :
2125 :
2126 : /**
2127 : * Mark windSpeed, which is an optional field, as non-existent.
2128 : */
2129 0 : void WeatherRow::clearWindSpeed () {
2130 0 : windSpeedExists = false;
2131 0 : }
2132 :
2133 :
2134 :
2135 : /**
2136 : * The attribute windMax is optional. Return true if this attribute exists.
2137 : * @return true if and only if the windMax attribute exists.
2138 : */
2139 0 : bool WeatherRow::isWindMaxExists() const {
2140 0 : return windMaxExists;
2141 : }
2142 :
2143 :
2144 :
2145 : /**
2146 : * Get windMax, which is optional.
2147 : * @return windMax as Speed
2148 : * @throw IllegalAccessException If windMax does not exist.
2149 : */
2150 0 : Speed WeatherRow::getWindMax() const {
2151 0 : if (!windMaxExists) {
2152 0 : throw IllegalAccessException("windMax", "Weather");
2153 : }
2154 :
2155 0 : return windMax;
2156 : }
2157 :
2158 : /**
2159 : * Set windMax with the specified Speed.
2160 : * @param windMax The Speed value to which windMax is to be set.
2161 :
2162 :
2163 : */
2164 15455 : void WeatherRow::setWindMax (Speed windMax) {
2165 :
2166 15455 : this->windMax = windMax;
2167 :
2168 15455 : windMaxExists = true;
2169 :
2170 15455 : }
2171 :
2172 :
2173 : /**
2174 : * Mark windMax, which is an optional field, as non-existent.
2175 : */
2176 0 : void WeatherRow::clearWindMax () {
2177 0 : windMaxExists = false;
2178 0 : }
2179 :
2180 :
2181 :
2182 : /**
2183 : * The attribute dewPoint is optional. Return true if this attribute exists.
2184 : * @return true if and only if the dewPoint attribute exists.
2185 : */
2186 4516 : bool WeatherRow::isDewPointExists() const {
2187 4516 : return dewPointExists;
2188 : }
2189 :
2190 :
2191 :
2192 : /**
2193 : * Get dewPoint, which is optional.
2194 : * @return dewPoint as Temperature
2195 : * @throw IllegalAccessException If dewPoint does not exist.
2196 : */
2197 229 : Temperature WeatherRow::getDewPoint() const {
2198 229 : if (!dewPointExists) {
2199 0 : throw IllegalAccessException("dewPoint", "Weather");
2200 : }
2201 :
2202 229 : return dewPoint;
2203 : }
2204 :
2205 : /**
2206 : * Set dewPoint with the specified Temperature.
2207 : * @param dewPoint The Temperature value to which dewPoint is to be set.
2208 :
2209 :
2210 : */
2211 416 : void WeatherRow::setDewPoint (Temperature dewPoint) {
2212 :
2213 416 : this->dewPoint = dewPoint;
2214 :
2215 416 : dewPointExists = true;
2216 :
2217 416 : }
2218 :
2219 :
2220 : /**
2221 : * Mark dewPoint, which is an optional field, as non-existent.
2222 : */
2223 0 : void WeatherRow::clearDewPoint () {
2224 0 : dewPointExists = false;
2225 0 : }
2226 :
2227 :
2228 :
2229 : /**
2230 : * The attribute numLayer is optional. Return true if this attribute exists.
2231 : * @return true if and only if the numLayer attribute exists.
2232 : */
2233 0 : bool WeatherRow::isNumLayerExists() const {
2234 0 : return numLayerExists;
2235 : }
2236 :
2237 :
2238 :
2239 : /**
2240 : * Get numLayer, which is optional.
2241 : * @return numLayer as int
2242 : * @throw IllegalAccessException If numLayer does not exist.
2243 : */
2244 0 : int WeatherRow::getNumLayer() const {
2245 0 : if (!numLayerExists) {
2246 0 : throw IllegalAccessException("numLayer", "Weather");
2247 : }
2248 :
2249 0 : return numLayer;
2250 : }
2251 :
2252 : /**
2253 : * Set numLayer with the specified int.
2254 : * @param numLayer The int value to which numLayer is to be set.
2255 :
2256 :
2257 : */
2258 0 : void WeatherRow::setNumLayer (int numLayer) {
2259 :
2260 0 : this->numLayer = numLayer;
2261 :
2262 0 : numLayerExists = true;
2263 :
2264 0 : }
2265 :
2266 :
2267 : /**
2268 : * Mark numLayer, which is an optional field, as non-existent.
2269 : */
2270 0 : void WeatherRow::clearNumLayer () {
2271 0 : numLayerExists = false;
2272 0 : }
2273 :
2274 :
2275 :
2276 : /**
2277 : * The attribute layerHeight is optional. Return true if this attribute exists.
2278 : * @return true if and only if the layerHeight attribute exists.
2279 : */
2280 0 : bool WeatherRow::isLayerHeightExists() const {
2281 0 : return layerHeightExists;
2282 : }
2283 :
2284 :
2285 :
2286 : /**
2287 : * Get layerHeight, which is optional.
2288 : * @return layerHeight as std::vector<Length >
2289 : * @throw IllegalAccessException If layerHeight does not exist.
2290 : */
2291 0 : std::vector<Length > WeatherRow::getLayerHeight() const {
2292 0 : if (!layerHeightExists) {
2293 0 : throw IllegalAccessException("layerHeight", "Weather");
2294 : }
2295 :
2296 0 : return layerHeight;
2297 : }
2298 :
2299 : /**
2300 : * Set layerHeight with the specified std::vector<Length >.
2301 : * @param layerHeight The std::vector<Length > value to which layerHeight is to be set.
2302 :
2303 :
2304 : */
2305 0 : void WeatherRow::setLayerHeight (std::vector<Length > layerHeight) {
2306 :
2307 0 : this->layerHeight = layerHeight;
2308 :
2309 0 : layerHeightExists = true;
2310 :
2311 0 : }
2312 :
2313 :
2314 : /**
2315 : * Mark layerHeight, which is an optional field, as non-existent.
2316 : */
2317 0 : void WeatherRow::clearLayerHeight () {
2318 0 : layerHeightExists = false;
2319 0 : }
2320 :
2321 :
2322 :
2323 : /**
2324 : * The attribute temperatureProfile is optional. Return true if this attribute exists.
2325 : * @return true if and only if the temperatureProfile attribute exists.
2326 : */
2327 0 : bool WeatherRow::isTemperatureProfileExists() const {
2328 0 : return temperatureProfileExists;
2329 : }
2330 :
2331 :
2332 :
2333 : /**
2334 : * Get temperatureProfile, which is optional.
2335 : * @return temperatureProfile as std::vector<Temperature >
2336 : * @throw IllegalAccessException If temperatureProfile does not exist.
2337 : */
2338 0 : std::vector<Temperature > WeatherRow::getTemperatureProfile() const {
2339 0 : if (!temperatureProfileExists) {
2340 0 : throw IllegalAccessException("temperatureProfile", "Weather");
2341 : }
2342 :
2343 0 : return temperatureProfile;
2344 : }
2345 :
2346 : /**
2347 : * Set temperatureProfile with the specified std::vector<Temperature >.
2348 : * @param temperatureProfile The std::vector<Temperature > value to which temperatureProfile is to be set.
2349 :
2350 :
2351 : */
2352 0 : void WeatherRow::setTemperatureProfile (std::vector<Temperature > temperatureProfile) {
2353 :
2354 0 : this->temperatureProfile = temperatureProfile;
2355 :
2356 0 : temperatureProfileExists = true;
2357 :
2358 0 : }
2359 :
2360 :
2361 : /**
2362 : * Mark temperatureProfile, which is an optional field, as non-existent.
2363 : */
2364 0 : void WeatherRow::clearTemperatureProfile () {
2365 0 : temperatureProfileExists = false;
2366 0 : }
2367 :
2368 :
2369 :
2370 : /**
2371 : * The attribute cloudMonitor is optional. Return true if this attribute exists.
2372 : * @return true if and only if the cloudMonitor attribute exists.
2373 : */
2374 0 : bool WeatherRow::isCloudMonitorExists() const {
2375 0 : return cloudMonitorExists;
2376 : }
2377 :
2378 :
2379 :
2380 : /**
2381 : * Get cloudMonitor, which is optional.
2382 : * @return cloudMonitor as Temperature
2383 : * @throw IllegalAccessException If cloudMonitor does not exist.
2384 : */
2385 0 : Temperature WeatherRow::getCloudMonitor() const {
2386 0 : if (!cloudMonitorExists) {
2387 0 : throw IllegalAccessException("cloudMonitor", "Weather");
2388 : }
2389 :
2390 0 : return cloudMonitor;
2391 : }
2392 :
2393 : /**
2394 : * Set cloudMonitor with the specified Temperature.
2395 : * @param cloudMonitor The Temperature value to which cloudMonitor is to be set.
2396 :
2397 :
2398 : */
2399 0 : void WeatherRow::setCloudMonitor (Temperature cloudMonitor) {
2400 :
2401 0 : this->cloudMonitor = cloudMonitor;
2402 :
2403 0 : cloudMonitorExists = true;
2404 :
2405 0 : }
2406 :
2407 :
2408 : /**
2409 : * Mark cloudMonitor, which is an optional field, as non-existent.
2410 : */
2411 0 : void WeatherRow::clearCloudMonitor () {
2412 0 : cloudMonitorExists = false;
2413 0 : }
2414 :
2415 :
2416 :
2417 : /**
2418 : * The attribute numWVR is optional. Return true if this attribute exists.
2419 : * @return true if and only if the numWVR attribute exists.
2420 : */
2421 0 : bool WeatherRow::isNumWVRExists() const {
2422 0 : return numWVRExists;
2423 : }
2424 :
2425 :
2426 :
2427 : /**
2428 : * Get numWVR, which is optional.
2429 : * @return numWVR as int
2430 : * @throw IllegalAccessException If numWVR does not exist.
2431 : */
2432 0 : int WeatherRow::getNumWVR() const {
2433 0 : if (!numWVRExists) {
2434 0 : throw IllegalAccessException("numWVR", "Weather");
2435 : }
2436 :
2437 0 : return numWVR;
2438 : }
2439 :
2440 : /**
2441 : * Set numWVR with the specified int.
2442 : * @param numWVR The int value to which numWVR is to be set.
2443 :
2444 :
2445 : */
2446 0 : void WeatherRow::setNumWVR (int numWVR) {
2447 :
2448 0 : this->numWVR = numWVR;
2449 :
2450 0 : numWVRExists = true;
2451 :
2452 0 : }
2453 :
2454 :
2455 : /**
2456 : * Mark numWVR, which is an optional field, as non-existent.
2457 : */
2458 0 : void WeatherRow::clearNumWVR () {
2459 0 : numWVRExists = false;
2460 0 : }
2461 :
2462 :
2463 :
2464 : /**
2465 : * The attribute wvrTemp is optional. Return true if this attribute exists.
2466 : * @return true if and only if the wvrTemp attribute exists.
2467 : */
2468 0 : bool WeatherRow::isWvrTempExists() const {
2469 0 : return wvrTempExists;
2470 : }
2471 :
2472 :
2473 :
2474 : /**
2475 : * Get wvrTemp, which is optional.
2476 : * @return wvrTemp as std::vector<Temperature >
2477 : * @throw IllegalAccessException If wvrTemp does not exist.
2478 : */
2479 0 : std::vector<Temperature > WeatherRow::getWvrTemp() const {
2480 0 : if (!wvrTempExists) {
2481 0 : throw IllegalAccessException("wvrTemp", "Weather");
2482 : }
2483 :
2484 0 : return wvrTemp;
2485 : }
2486 :
2487 : /**
2488 : * Set wvrTemp with the specified std::vector<Temperature >.
2489 : * @param wvrTemp The std::vector<Temperature > value to which wvrTemp is to be set.
2490 :
2491 :
2492 : */
2493 0 : void WeatherRow::setWvrTemp (std::vector<Temperature > wvrTemp) {
2494 :
2495 0 : this->wvrTemp = wvrTemp;
2496 :
2497 0 : wvrTempExists = true;
2498 :
2499 0 : }
2500 :
2501 :
2502 : /**
2503 : * Mark wvrTemp, which is an optional field, as non-existent.
2504 : */
2505 0 : void WeatherRow::clearWvrTemp () {
2506 0 : wvrTempExists = false;
2507 0 : }
2508 :
2509 :
2510 :
2511 : /**
2512 : * The attribute water is optional. Return true if this attribute exists.
2513 : * @return true if and only if the water attribute exists.
2514 : */
2515 0 : bool WeatherRow::isWaterExists() const {
2516 0 : return waterExists;
2517 : }
2518 :
2519 :
2520 :
2521 : /**
2522 : * Get water, which is optional.
2523 : * @return water as double
2524 : * @throw IllegalAccessException If water does not exist.
2525 : */
2526 0 : double WeatherRow::getWater() const {
2527 0 : if (!waterExists) {
2528 0 : throw IllegalAccessException("water", "Weather");
2529 : }
2530 :
2531 0 : return water;
2532 : }
2533 :
2534 : /**
2535 : * Set water with the specified double.
2536 : * @param water The double value to which water is to be set.
2537 :
2538 :
2539 : */
2540 0 : void WeatherRow::setWater (double water) {
2541 :
2542 0 : this->water = water;
2543 :
2544 0 : waterExists = true;
2545 :
2546 0 : }
2547 :
2548 :
2549 : /**
2550 : * Mark water, which is an optional field, as non-existent.
2551 : */
2552 0 : void WeatherRow::clearWater () {
2553 0 : waterExists = false;
2554 0 : }
2555 :
2556 :
2557 :
2558 : ///////////////////////////////////////////////
2559 : // Extrinsic Table Attributes getters/setters//
2560 : ///////////////////////////////////////////////
2561 :
2562 :
2563 :
2564 :
2565 : /**
2566 : * Get stationId.
2567 : * @return stationId as Tag
2568 : */
2569 19971 : Tag WeatherRow::getStationId() const {
2570 :
2571 19971 : return stationId;
2572 : }
2573 :
2574 : /**
2575 : * Set stationId with the specified Tag.
2576 : * @param stationId The Tag value to which stationId is to be set.
2577 :
2578 :
2579 :
2580 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2581 :
2582 : */
2583 15455 : void WeatherRow::setStationId (Tag stationId) {
2584 :
2585 :
2586 15455 : if (hasBeenAdded) {
2587 :
2588 0 : throw IllegalAccessException("stationId", "Weather");
2589 :
2590 : }
2591 :
2592 15455 : this->stationId = stationId;
2593 :
2594 15455 : }
2595 :
2596 :
2597 :
2598 :
2599 : //////////////////////////////////////
2600 : // Links Attributes getters/setters //
2601 : //////////////////////////////////////
2602 :
2603 :
2604 :
2605 :
2606 :
2607 :
2608 : /**
2609 : * Returns the pointer to the row in the Station table having Station.stationId == stationId
2610 : * @return a StationRow*
2611 : *
2612 :
2613 : */
2614 4516 : StationRow* WeatherRow::getStationUsingStationId() {
2615 :
2616 4516 : return table.getContainer().getStation().getRowByKey(stationId);
2617 : }
2618 :
2619 :
2620 :
2621 :
2622 :
2623 : /**
2624 : * Create a WeatherRow.
2625 : * <p>
2626 : * This constructor is private because only the
2627 : * table can create rows. All rows know the table
2628 : * to which they belong.
2629 : * @param table The table to which this row belongs.
2630 : */
2631 15455 : WeatherRow::WeatherRow (WeatherTable &t) : table(t) {
2632 15455 : hasBeenAdded = false;
2633 :
2634 :
2635 :
2636 :
2637 :
2638 15455 : pressureExists = false;
2639 :
2640 :
2641 :
2642 15455 : relHumidityExists = false;
2643 :
2644 :
2645 :
2646 15455 : temperatureExists = false;
2647 :
2648 :
2649 :
2650 15455 : windDirectionExists = false;
2651 :
2652 :
2653 :
2654 15455 : windSpeedExists = false;
2655 :
2656 :
2657 :
2658 15455 : windMaxExists = false;
2659 :
2660 :
2661 :
2662 15455 : dewPointExists = false;
2663 :
2664 :
2665 :
2666 15455 : numLayerExists = false;
2667 :
2668 :
2669 :
2670 15455 : layerHeightExists = false;
2671 :
2672 :
2673 :
2674 15455 : temperatureProfileExists = false;
2675 :
2676 :
2677 :
2678 15455 : cloudMonitorExists = false;
2679 :
2680 :
2681 :
2682 15455 : numWVRExists = false;
2683 :
2684 :
2685 :
2686 15455 : wvrTempExists = false;
2687 :
2688 :
2689 :
2690 15455 : waterExists = false;
2691 :
2692 :
2693 :
2694 :
2695 :
2696 :
2697 :
2698 :
2699 :
2700 :
2701 :
2702 :
2703 :
2704 :
2705 :
2706 :
2707 :
2708 :
2709 :
2710 :
2711 :
2712 :
2713 :
2714 :
2715 :
2716 :
2717 :
2718 :
2719 :
2720 :
2721 :
2722 :
2723 :
2724 :
2725 :
2726 :
2727 :
2728 :
2729 :
2730 :
2731 15455 : fromBinMethods["stationId"] = &WeatherRow::stationIdFromBin;
2732 15455 : fromBinMethods["timeInterval"] = &WeatherRow::timeIntervalFromBin;
2733 :
2734 :
2735 15455 : fromBinMethods["pressure"] = &WeatherRow::pressureFromBin;
2736 15455 : fromBinMethods["relHumidity"] = &WeatherRow::relHumidityFromBin;
2737 15455 : fromBinMethods["temperature"] = &WeatherRow::temperatureFromBin;
2738 15455 : fromBinMethods["windDirection"] = &WeatherRow::windDirectionFromBin;
2739 15455 : fromBinMethods["windSpeed"] = &WeatherRow::windSpeedFromBin;
2740 15455 : fromBinMethods["windMax"] = &WeatherRow::windMaxFromBin;
2741 15455 : fromBinMethods["dewPoint"] = &WeatherRow::dewPointFromBin;
2742 15455 : fromBinMethods["numLayer"] = &WeatherRow::numLayerFromBin;
2743 15455 : fromBinMethods["layerHeight"] = &WeatherRow::layerHeightFromBin;
2744 15455 : fromBinMethods["temperatureProfile"] = &WeatherRow::temperatureProfileFromBin;
2745 15455 : fromBinMethods["cloudMonitor"] = &WeatherRow::cloudMonitorFromBin;
2746 15455 : fromBinMethods["numWVR"] = &WeatherRow::numWVRFromBin;
2747 15455 : fromBinMethods["wvrTemp"] = &WeatherRow::wvrTempFromBin;
2748 15455 : fromBinMethods["water"] = &WeatherRow::waterFromBin;
2749 :
2750 :
2751 :
2752 :
2753 :
2754 15455 : fromTextMethods["stationId"] = &WeatherRow::stationIdFromText;
2755 :
2756 :
2757 :
2758 15455 : fromTextMethods["timeInterval"] = &WeatherRow::timeIntervalFromText;
2759 :
2760 :
2761 :
2762 :
2763 :
2764 15455 : fromTextMethods["pressure"] = &WeatherRow::pressureFromText;
2765 :
2766 :
2767 :
2768 15455 : fromTextMethods["relHumidity"] = &WeatherRow::relHumidityFromText;
2769 :
2770 :
2771 :
2772 15455 : fromTextMethods["temperature"] = &WeatherRow::temperatureFromText;
2773 :
2774 :
2775 :
2776 15455 : fromTextMethods["windDirection"] = &WeatherRow::windDirectionFromText;
2777 :
2778 :
2779 :
2780 15455 : fromTextMethods["windSpeed"] = &WeatherRow::windSpeedFromText;
2781 :
2782 :
2783 :
2784 15455 : fromTextMethods["windMax"] = &WeatherRow::windMaxFromText;
2785 :
2786 :
2787 :
2788 15455 : fromTextMethods["dewPoint"] = &WeatherRow::dewPointFromText;
2789 :
2790 :
2791 :
2792 15455 : fromTextMethods["numLayer"] = &WeatherRow::numLayerFromText;
2793 :
2794 :
2795 :
2796 15455 : fromTextMethods["layerHeight"] = &WeatherRow::layerHeightFromText;
2797 :
2798 :
2799 :
2800 15455 : fromTextMethods["temperatureProfile"] = &WeatherRow::temperatureProfileFromText;
2801 :
2802 :
2803 :
2804 15455 : fromTextMethods["cloudMonitor"] = &WeatherRow::cloudMonitorFromText;
2805 :
2806 :
2807 :
2808 15455 : fromTextMethods["numWVR"] = &WeatherRow::numWVRFromText;
2809 :
2810 :
2811 :
2812 15455 : fromTextMethods["wvrTemp"] = &WeatherRow::wvrTempFromText;
2813 :
2814 :
2815 :
2816 15455 : fromTextMethods["water"] = &WeatherRow::waterFromText;
2817 :
2818 :
2819 15455 : }
2820 :
2821 0 : WeatherRow::WeatherRow (WeatherTable &t, WeatherRow *row) : table(t) {
2822 0 : hasBeenAdded = false;
2823 :
2824 0 : if (row == 0) {
2825 :
2826 :
2827 :
2828 :
2829 :
2830 0 : pressureExists = false;
2831 :
2832 :
2833 :
2834 0 : relHumidityExists = false;
2835 :
2836 :
2837 :
2838 0 : temperatureExists = false;
2839 :
2840 :
2841 :
2842 0 : windDirectionExists = false;
2843 :
2844 :
2845 :
2846 0 : windSpeedExists = false;
2847 :
2848 :
2849 :
2850 0 : windMaxExists = false;
2851 :
2852 :
2853 :
2854 0 : dewPointExists = false;
2855 :
2856 :
2857 :
2858 0 : numLayerExists = false;
2859 :
2860 :
2861 :
2862 0 : layerHeightExists = false;
2863 :
2864 :
2865 :
2866 0 : temperatureProfileExists = false;
2867 :
2868 :
2869 :
2870 0 : cloudMonitorExists = false;
2871 :
2872 :
2873 :
2874 0 : numWVRExists = false;
2875 :
2876 :
2877 :
2878 0 : wvrTempExists = false;
2879 :
2880 :
2881 :
2882 0 : waterExists = false;
2883 :
2884 :
2885 :
2886 :
2887 :
2888 : }
2889 : else {
2890 :
2891 :
2892 0 : stationId = row->stationId;
2893 :
2894 0 : timeInterval = row->timeInterval;
2895 :
2896 :
2897 :
2898 :
2899 :
2900 :
2901 :
2902 0 : if (row->pressureExists) {
2903 0 : pressure = row->pressure;
2904 0 : pressureExists = true;
2905 : }
2906 : else
2907 0 : pressureExists = false;
2908 :
2909 0 : if (row->relHumidityExists) {
2910 0 : relHumidity = row->relHumidity;
2911 0 : relHumidityExists = true;
2912 : }
2913 : else
2914 0 : relHumidityExists = false;
2915 :
2916 0 : if (row->temperatureExists) {
2917 0 : temperature = row->temperature;
2918 0 : temperatureExists = true;
2919 : }
2920 : else
2921 0 : temperatureExists = false;
2922 :
2923 0 : if (row->windDirectionExists) {
2924 0 : windDirection = row->windDirection;
2925 0 : windDirectionExists = true;
2926 : }
2927 : else
2928 0 : windDirectionExists = false;
2929 :
2930 0 : if (row->windSpeedExists) {
2931 0 : windSpeed = row->windSpeed;
2932 0 : windSpeedExists = true;
2933 : }
2934 : else
2935 0 : windSpeedExists = false;
2936 :
2937 0 : if (row->windMaxExists) {
2938 0 : windMax = row->windMax;
2939 0 : windMaxExists = true;
2940 : }
2941 : else
2942 0 : windMaxExists = false;
2943 :
2944 0 : if (row->dewPointExists) {
2945 0 : dewPoint = row->dewPoint;
2946 0 : dewPointExists = true;
2947 : }
2948 : else
2949 0 : dewPointExists = false;
2950 :
2951 0 : if (row->numLayerExists) {
2952 0 : numLayer = row->numLayer;
2953 0 : numLayerExists = true;
2954 : }
2955 : else
2956 0 : numLayerExists = false;
2957 :
2958 0 : if (row->layerHeightExists) {
2959 0 : layerHeight = row->layerHeight;
2960 0 : layerHeightExists = true;
2961 : }
2962 : else
2963 0 : layerHeightExists = false;
2964 :
2965 0 : if (row->temperatureProfileExists) {
2966 0 : temperatureProfile = row->temperatureProfile;
2967 0 : temperatureProfileExists = true;
2968 : }
2969 : else
2970 0 : temperatureProfileExists = false;
2971 :
2972 0 : if (row->cloudMonitorExists) {
2973 0 : cloudMonitor = row->cloudMonitor;
2974 0 : cloudMonitorExists = true;
2975 : }
2976 : else
2977 0 : cloudMonitorExists = false;
2978 :
2979 0 : if (row->numWVRExists) {
2980 0 : numWVR = row->numWVR;
2981 0 : numWVRExists = true;
2982 : }
2983 : else
2984 0 : numWVRExists = false;
2985 :
2986 0 : if (row->wvrTempExists) {
2987 0 : wvrTemp = row->wvrTemp;
2988 0 : wvrTempExists = true;
2989 : }
2990 : else
2991 0 : wvrTempExists = false;
2992 :
2993 0 : if (row->waterExists) {
2994 0 : water = row->water;
2995 0 : waterExists = true;
2996 : }
2997 : else
2998 0 : waterExists = false;
2999 :
3000 : }
3001 :
3002 0 : fromBinMethods["stationId"] = &WeatherRow::stationIdFromBin;
3003 0 : fromBinMethods["timeInterval"] = &WeatherRow::timeIntervalFromBin;
3004 :
3005 :
3006 0 : fromBinMethods["pressure"] = &WeatherRow::pressureFromBin;
3007 0 : fromBinMethods["relHumidity"] = &WeatherRow::relHumidityFromBin;
3008 0 : fromBinMethods["temperature"] = &WeatherRow::temperatureFromBin;
3009 0 : fromBinMethods["windDirection"] = &WeatherRow::windDirectionFromBin;
3010 0 : fromBinMethods["windSpeed"] = &WeatherRow::windSpeedFromBin;
3011 0 : fromBinMethods["windMax"] = &WeatherRow::windMaxFromBin;
3012 0 : fromBinMethods["dewPoint"] = &WeatherRow::dewPointFromBin;
3013 0 : fromBinMethods["numLayer"] = &WeatherRow::numLayerFromBin;
3014 0 : fromBinMethods["layerHeight"] = &WeatherRow::layerHeightFromBin;
3015 0 : fromBinMethods["temperatureProfile"] = &WeatherRow::temperatureProfileFromBin;
3016 0 : fromBinMethods["cloudMonitor"] = &WeatherRow::cloudMonitorFromBin;
3017 0 : fromBinMethods["numWVR"] = &WeatherRow::numWVRFromBin;
3018 0 : fromBinMethods["wvrTemp"] = &WeatherRow::wvrTempFromBin;
3019 0 : fromBinMethods["water"] = &WeatherRow::waterFromBin;
3020 :
3021 0 : }
3022 :
3023 :
3024 0 : bool WeatherRow::compareNoAutoInc(Tag stationId, ArrayTimeInterval timeInterval) {
3025 : bool result;
3026 0 : result = true;
3027 :
3028 :
3029 :
3030 0 : result = result && (this->stationId == stationId);
3031 :
3032 0 : if (!result) return false;
3033 :
3034 :
3035 :
3036 :
3037 0 : result = result && (this->timeInterval.overlaps(timeInterval));
3038 :
3039 0 : if (!result) return false;
3040 :
3041 :
3042 0 : return result;
3043 : }
3044 :
3045 :
3046 :
3047 :
3048 : /**
3049 : * Return true if all required attributes of the value part are equal to their homologues
3050 : * in x and false otherwise.
3051 : *
3052 :
3053 : * will be compared with those of this.
3054 : * @return a boolean.
3055 : */
3056 0 : bool WeatherRow::equalByRequiredValue(WeatherRow* ) {
3057 :
3058 0 : return true;
3059 : }
3060 :
3061 : /*
3062 : map<string, WeatherAttributeFromBin> WeatherRow::initFromBinMethods() {
3063 : map<string, WeatherAttributeFromBin> result;
3064 :
3065 : result["stationId"] = &WeatherRow::stationIdFromBin;
3066 : result["timeInterval"] = &WeatherRow::timeIntervalFromBin;
3067 :
3068 :
3069 : result["pressure"] = &WeatherRow::pressureFromBin;
3070 : result["relHumidity"] = &WeatherRow::relHumidityFromBin;
3071 : result["temperature"] = &WeatherRow::temperatureFromBin;
3072 : result["windDirection"] = &WeatherRow::windDirectionFromBin;
3073 : result["windSpeed"] = &WeatherRow::windSpeedFromBin;
3074 : result["windMax"] = &WeatherRow::windMaxFromBin;
3075 : result["dewPoint"] = &WeatherRow::dewPointFromBin;
3076 : result["numLayer"] = &WeatherRow::numLayerFromBin;
3077 : result["layerHeight"] = &WeatherRow::layerHeightFromBin;
3078 : result["temperatureProfile"] = &WeatherRow::temperatureProfileFromBin;
3079 : result["cloudMonitor"] = &WeatherRow::cloudMonitorFromBin;
3080 : result["numWVR"] = &WeatherRow::numWVRFromBin;
3081 : result["wvrTemp"] = &WeatherRow::wvrTempFromBin;
3082 : result["water"] = &WeatherRow::waterFromBin;
3083 :
3084 :
3085 : return result;
3086 : }
3087 : */
3088 : } // End namespace asdm
3089 :
|
