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 MainRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/MainRow.h>
39 : #include <alma/ASDM/MainTable.h>
40 :
41 : #include <alma/ASDM/ConfigDescriptionTable.h>
42 : #include <alma/ASDM/ConfigDescriptionRow.h>
43 :
44 : #include <alma/ASDM/FieldTable.h>
45 : #include <alma/ASDM/FieldRow.h>
46 :
47 : #include <alma/ASDM/StateTable.h>
48 : #include <alma/ASDM/StateRow.h>
49 :
50 : #include <alma/ASDM/ExecBlockTable.h>
51 : #include <alma/ASDM/ExecBlockRow.h>
52 :
53 :
54 : using asdm::ASDM;
55 : using asdm::MainRow;
56 : using asdm::MainTable;
57 :
58 : using asdm::ConfigDescriptionTable;
59 : using asdm::ConfigDescriptionRow;
60 :
61 : using asdm::FieldTable;
62 : using asdm::FieldRow;
63 :
64 : using asdm::StateTable;
65 : using asdm::StateRow;
66 :
67 : using asdm::ExecBlockTable;
68 : using asdm::ExecBlockRow;
69 :
70 :
71 : #include <alma/ASDM/Parser.h>
72 :
73 : #include <alma/ASDM/EnumerationParser.h>
74 : #include <alma/ASDM/ASDMValuesParser.h>
75 :
76 : #include <alma/ASDM/InvalidArgumentException.h>
77 :
78 : using namespace std;
79 :
80 : namespace asdm {
81 16326 : MainRow::~MainRow() {
82 16326 : }
83 :
84 : /**
85 : * Return the table to which this row belongs.
86 : */
87 13844935 : MainTable &MainRow::getTable() const {
88 13844935 : return table;
89 : }
90 :
91 0 : bool MainRow::isAdded() const {
92 0 : return hasBeenAdded;
93 : }
94 :
95 8163 : void MainRow::isAdded(bool added) {
96 8163 : hasBeenAdded = added;
97 8163 : }
98 :
99 : #ifndef WITHOUT_ACS
100 : using asdmIDL::MainRowIDL;
101 : #endif
102 :
103 : #ifndef WITHOUT_ACS
104 : /**
105 : * Return this row in the form of an IDL struct.
106 : * @return The values of this row as a MainRowIDL struct.
107 : */
108 : MainRowIDL *MainRow::toIDL() const {
109 : MainRowIDL *x = new MainRowIDL ();
110 :
111 : // Fill the IDL structure.
112 :
113 :
114 :
115 :
116 :
117 :
118 :
119 : x->time = time.toIDLArrayTime();
120 :
121 :
122 :
123 :
124 :
125 :
126 :
127 :
128 :
129 :
130 : x->numAntenna = numAntenna;
131 :
132 :
133 :
134 :
135 :
136 :
137 :
138 :
139 :
140 :
141 :
142 : x->timeSampling = timeSampling;
143 :
144 :
145 :
146 :
147 :
148 :
149 :
150 :
151 :
152 :
153 : x->interval = interval.toIDLInterval();
154 :
155 :
156 :
157 :
158 :
159 :
160 :
161 :
162 :
163 :
164 : x->numIntegration = numIntegration;
165 :
166 :
167 :
168 :
169 :
170 :
171 :
172 :
173 :
174 :
175 :
176 : x->scanNumber = scanNumber;
177 :
178 :
179 :
180 :
181 :
182 :
183 :
184 :
185 :
186 :
187 :
188 : x->subscanNumber = subscanNumber;
189 :
190 :
191 :
192 :
193 :
194 :
195 :
196 :
197 :
198 :
199 :
200 : x->dataSize = dataSize;
201 :
202 :
203 :
204 :
205 :
206 :
207 :
208 :
209 :
210 :
211 : x->dataUID = dataUID.toIDLEntityRef();
212 :
213 :
214 :
215 :
216 :
217 :
218 :
219 :
220 :
221 :
222 :
223 :
224 :
225 : x->configDescriptionId = configDescriptionId.toIDLTag();
226 :
227 :
228 :
229 :
230 :
231 :
232 :
233 :
234 :
235 :
236 : x->execBlockId = execBlockId.toIDLTag();
237 :
238 :
239 :
240 :
241 :
242 :
243 :
244 :
245 :
246 :
247 : x->fieldId = fieldId.toIDLTag();
248 :
249 :
250 :
251 :
252 :
253 :
254 :
255 :
256 :
257 : x->stateId.length(stateId.size());
258 : for (unsigned int i = 0; i < stateId.size(); ++i) {
259 :
260 : x->stateId[i] = stateId.at(i).toIDLTag();
261 :
262 : }
263 :
264 :
265 :
266 :
267 :
268 :
269 :
270 :
271 :
272 :
273 :
274 :
275 :
276 :
277 : return x;
278 :
279 : }
280 :
281 : void MainRow::toIDL(asdmIDL::MainRowIDL& x) const {
282 : // Set the x's fields.
283 :
284 :
285 :
286 :
287 :
288 :
289 :
290 : x.time = time.toIDLArrayTime();
291 :
292 :
293 :
294 :
295 :
296 :
297 :
298 :
299 :
300 :
301 : x.numAntenna = numAntenna;
302 :
303 :
304 :
305 :
306 :
307 :
308 :
309 :
310 :
311 :
312 :
313 : x.timeSampling = timeSampling;
314 :
315 :
316 :
317 :
318 :
319 :
320 :
321 :
322 :
323 :
324 : x.interval = interval.toIDLInterval();
325 :
326 :
327 :
328 :
329 :
330 :
331 :
332 :
333 :
334 :
335 : x.numIntegration = numIntegration;
336 :
337 :
338 :
339 :
340 :
341 :
342 :
343 :
344 :
345 :
346 :
347 : x.scanNumber = scanNumber;
348 :
349 :
350 :
351 :
352 :
353 :
354 :
355 :
356 :
357 :
358 :
359 : x.subscanNumber = subscanNumber;
360 :
361 :
362 :
363 :
364 :
365 :
366 :
367 :
368 :
369 :
370 :
371 : x.dataSize = dataSize;
372 :
373 :
374 :
375 :
376 :
377 :
378 :
379 :
380 :
381 :
382 : x.dataUID = dataUID.toIDLEntityRef();
383 :
384 :
385 :
386 :
387 :
388 :
389 :
390 :
391 :
392 :
393 :
394 :
395 :
396 : x.configDescriptionId = configDescriptionId.toIDLTag();
397 :
398 :
399 :
400 :
401 :
402 :
403 :
404 :
405 :
406 :
407 : x.execBlockId = execBlockId.toIDLTag();
408 :
409 :
410 :
411 :
412 :
413 :
414 :
415 :
416 :
417 :
418 : x.fieldId = fieldId.toIDLTag();
419 :
420 :
421 :
422 :
423 :
424 :
425 :
426 :
427 :
428 : x.stateId.length(stateId.size());
429 : for (unsigned int i = 0; i < stateId.size(); ++i) {
430 :
431 : x.stateId[i] = stateId.at(i).toIDLTag();
432 :
433 : }
434 :
435 :
436 :
437 :
438 :
439 :
440 :
441 :
442 :
443 :
444 :
445 :
446 :
447 :
448 : }
449 : #endif
450 :
451 :
452 : #ifndef WITHOUT_ACS
453 : /**
454 : * Fill the values of this row from the IDL struct MainRowIDL.
455 : * @param x The IDL struct containing the values used to fill this row.
456 : */
457 : void MainRow::setFromIDL (MainRowIDL x){
458 : try {
459 : // Fill the values from x.
460 :
461 :
462 :
463 :
464 :
465 :
466 : setTime(ArrayTime (x.time));
467 :
468 :
469 :
470 :
471 :
472 :
473 :
474 :
475 :
476 : setNumAntenna(x.numAntenna);
477 :
478 :
479 :
480 :
481 :
482 :
483 :
484 :
485 :
486 : setTimeSampling(x.timeSampling);
487 :
488 :
489 :
490 :
491 :
492 :
493 :
494 :
495 :
496 : setInterval(Interval (x.interval));
497 :
498 :
499 :
500 :
501 :
502 :
503 :
504 :
505 :
506 : setNumIntegration(x.numIntegration);
507 :
508 :
509 :
510 :
511 :
512 :
513 :
514 :
515 :
516 : setScanNumber(x.scanNumber);
517 :
518 :
519 :
520 :
521 :
522 :
523 :
524 :
525 :
526 : setSubscanNumber(x.subscanNumber);
527 :
528 :
529 :
530 :
531 :
532 :
533 :
534 :
535 :
536 : setDataSize(x.dataSize);
537 :
538 :
539 :
540 :
541 :
542 :
543 :
544 :
545 :
546 : setDataUID(EntityRef (x.dataUID));
547 :
548 :
549 :
550 :
551 :
552 :
553 :
554 :
555 :
556 :
557 :
558 :
559 : setConfigDescriptionId(Tag (x.configDescriptionId));
560 :
561 :
562 :
563 :
564 :
565 :
566 :
567 :
568 :
569 : setExecBlockId(Tag (x.execBlockId));
570 :
571 :
572 :
573 :
574 :
575 :
576 :
577 :
578 :
579 : setFieldId(Tag (x.fieldId));
580 :
581 :
582 :
583 :
584 :
585 :
586 :
587 : stateId .clear();
588 : for (unsigned int i = 0; i <x.stateId.length(); ++i) {
589 :
590 : stateId.push_back(Tag (x.stateId[i]));
591 :
592 : }
593 :
594 :
595 :
596 :
597 :
598 :
599 :
600 :
601 :
602 :
603 :
604 :
605 :
606 : } catch (const IllegalAccessException &err) {
607 : throw ConversionException (err.getMessage(),"Main");
608 : }
609 : }
610 : #endif
611 :
612 : /**
613 : * Return this row in the form of an XML string.
614 : * @return The values of this row as an XML string.
615 : */
616 536 : string MainRow::toXML() const {
617 536 : string buf;
618 536 : buf.append("<row> \n");
619 :
620 :
621 :
622 :
623 :
624 :
625 536 : Parser::toXML(time, "time", buf);
626 :
627 :
628 :
629 :
630 :
631 :
632 :
633 536 : Parser::toXML(numAntenna, "numAntenna", buf);
634 :
635 :
636 :
637 :
638 :
639 :
640 :
641 536 : buf.append(EnumerationParser::toXML("timeSampling", timeSampling));
642 :
643 :
644 :
645 :
646 :
647 :
648 :
649 536 : Parser::toXML(interval, "interval", buf);
650 :
651 :
652 :
653 :
654 :
655 :
656 :
657 536 : Parser::toXML(numIntegration, "numIntegration", buf);
658 :
659 :
660 :
661 :
662 :
663 :
664 :
665 536 : Parser::toXML(scanNumber, "scanNumber", buf);
666 :
667 :
668 :
669 :
670 :
671 :
672 :
673 536 : Parser::toXML(subscanNumber, "subscanNumber", buf);
674 :
675 :
676 :
677 :
678 :
679 :
680 :
681 536 : Parser::toXML(dataSize, "dataSize", buf);
682 :
683 :
684 :
685 :
686 :
687 :
688 :
689 536 : Parser::toXML(dataUID, "dataUID", buf);
690 :
691 :
692 :
693 :
694 :
695 :
696 :
697 :
698 :
699 :
700 536 : Parser::toXML(configDescriptionId, "configDescriptionId", buf);
701 :
702 :
703 :
704 :
705 :
706 :
707 :
708 536 : Parser::toXML(execBlockId, "execBlockId", buf);
709 :
710 :
711 :
712 :
713 :
714 :
715 :
716 536 : Parser::toXML(fieldId, "fieldId", buf);
717 :
718 :
719 :
720 :
721 :
722 :
723 :
724 536 : Parser::toXML(stateId, "stateId", buf);
725 :
726 :
727 :
728 :
729 :
730 :
731 :
732 :
733 :
734 :
735 :
736 :
737 :
738 :
739 :
740 536 : buf.append("</row>\n");
741 536 : return buf;
742 : }
743 :
744 : /**
745 : * Fill the values of this row from an XML string
746 : * that was produced by the toXML() method.
747 : * @param x The XML string being used to set the values of this row.
748 : */
749 7627 : void MainRow::setFromXML (string rowDoc) {
750 15254 : Parser row(rowDoc);
751 7627 : string s = "";
752 : try {
753 :
754 :
755 :
756 :
757 :
758 7627 : setTime(Parser::getArrayTime("time","Main",rowDoc));
759 :
760 :
761 :
762 :
763 :
764 :
765 :
766 7627 : setNumAntenna(Parser::getInteger("numAntenna","Main",rowDoc));
767 :
768 :
769 :
770 :
771 :
772 :
773 :
774 :
775 7627 : timeSampling = EnumerationParser::getTimeSampling("timeSampling","Main",rowDoc);
776 :
777 :
778 :
779 :
780 :
781 :
782 :
783 :
784 7627 : setInterval(Parser::getInterval("interval","Main",rowDoc));
785 :
786 :
787 :
788 :
789 :
790 :
791 :
792 7627 : setNumIntegration(Parser::getInteger("numIntegration","Main",rowDoc));
793 :
794 :
795 :
796 :
797 :
798 :
799 :
800 7627 : setScanNumber(Parser::getInteger("scanNumber","Main",rowDoc));
801 :
802 :
803 :
804 :
805 :
806 :
807 :
808 7627 : setSubscanNumber(Parser::getInteger("subscanNumber","Main",rowDoc));
809 :
810 :
811 :
812 :
813 :
814 :
815 :
816 7627 : setDataSize(Parser::getLong("dataSize","Main",rowDoc));
817 :
818 :
819 :
820 :
821 :
822 :
823 :
824 7627 : setDataUID(Parser::getEntityRef("dataUID","Main",rowDoc));
825 :
826 :
827 :
828 :
829 :
830 :
831 :
832 :
833 :
834 :
835 7627 : setConfigDescriptionId(Parser::getTag("configDescriptionId","ConfigDescription",rowDoc));
836 :
837 :
838 :
839 :
840 :
841 :
842 :
843 7627 : setExecBlockId(Parser::getTag("execBlockId","Main",rowDoc));
844 :
845 :
846 :
847 :
848 :
849 :
850 :
851 7627 : setFieldId(Parser::getTag("fieldId","Field",rowDoc));
852 :
853 :
854 :
855 :
856 :
857 :
858 7627 : setStateId(Parser::get1DTag("stateId","Main",rowDoc));
859 :
860 :
861 :
862 :
863 :
864 :
865 :
866 :
867 :
868 :
869 :
870 :
871 :
872 0 : } catch (const IllegalAccessException &err) {
873 0 : throw ConversionException (err.getMessage(),"Main");
874 : }
875 7627 : }
876 :
877 0 : void MainRow::toBin(EndianOSStream& eoss) {
878 :
879 :
880 :
881 :
882 :
883 0 : time.toBin(eoss);
884 :
885 :
886 :
887 :
888 :
889 :
890 0 : configDescriptionId.toBin(eoss);
891 :
892 :
893 :
894 :
895 :
896 :
897 0 : fieldId.toBin(eoss);
898 :
899 :
900 :
901 :
902 :
903 :
904 :
905 0 : eoss.writeInt(numAntenna);
906 :
907 :
908 :
909 :
910 :
911 :
912 :
913 :
914 0 : eoss.writeString(CTimeSampling::name(timeSampling));
915 : /* eoss.writeInt(timeSampling); */
916 :
917 :
918 :
919 :
920 :
921 :
922 :
923 0 : interval.toBin(eoss);
924 :
925 :
926 :
927 :
928 :
929 :
930 :
931 0 : eoss.writeInt(numIntegration);
932 :
933 :
934 :
935 :
936 :
937 :
938 :
939 :
940 0 : eoss.writeInt(scanNumber);
941 :
942 :
943 :
944 :
945 :
946 :
947 :
948 :
949 0 : eoss.writeInt(subscanNumber);
950 :
951 :
952 :
953 :
954 :
955 :
956 :
957 :
958 0 : eoss.writeLong(dataSize);
959 :
960 :
961 :
962 :
963 :
964 :
965 :
966 0 : dataUID.toBin(eoss);
967 :
968 :
969 :
970 :
971 :
972 :
973 0 : Tag::toBin(stateId, eoss);
974 :
975 :
976 :
977 :
978 :
979 :
980 0 : execBlockId.toBin(eoss);
981 :
982 :
983 :
984 :
985 :
986 :
987 0 : }
988 :
989 0 : void MainRow::timeFromBin(EndianIStream& eis) {
990 :
991 :
992 :
993 :
994 0 : time = ArrayTime::fromBin(eis);
995 :
996 :
997 :
998 0 : }
999 0 : void MainRow::configDescriptionIdFromBin(EndianIStream& eis) {
1000 :
1001 :
1002 :
1003 :
1004 0 : configDescriptionId = Tag::fromBin(eis);
1005 :
1006 :
1007 :
1008 0 : }
1009 0 : void MainRow::fieldIdFromBin(EndianIStream& eis) {
1010 :
1011 :
1012 :
1013 :
1014 0 : fieldId = Tag::fromBin(eis);
1015 :
1016 :
1017 :
1018 0 : }
1019 0 : void MainRow::numAntennaFromBin(EndianIStream& eis) {
1020 :
1021 :
1022 :
1023 :
1024 :
1025 0 : numAntenna = eis.readInt();
1026 :
1027 :
1028 :
1029 :
1030 0 : }
1031 0 : void MainRow::timeSamplingFromBin(EndianIStream& eis) {
1032 :
1033 :
1034 :
1035 :
1036 :
1037 0 : timeSampling = CTimeSampling::literal(eis.readString());
1038 :
1039 :
1040 :
1041 :
1042 0 : }
1043 0 : void MainRow::intervalFromBin(EndianIStream& eis) {
1044 :
1045 :
1046 :
1047 :
1048 0 : interval = Interval::fromBin(eis);
1049 :
1050 :
1051 :
1052 0 : }
1053 0 : void MainRow::numIntegrationFromBin(EndianIStream& eis) {
1054 :
1055 :
1056 :
1057 :
1058 :
1059 0 : numIntegration = eis.readInt();
1060 :
1061 :
1062 :
1063 :
1064 0 : }
1065 0 : void MainRow::scanNumberFromBin(EndianIStream& eis) {
1066 :
1067 :
1068 :
1069 :
1070 :
1071 0 : scanNumber = eis.readInt();
1072 :
1073 :
1074 :
1075 :
1076 0 : }
1077 0 : void MainRow::subscanNumberFromBin(EndianIStream& eis) {
1078 :
1079 :
1080 :
1081 :
1082 :
1083 0 : subscanNumber = eis.readInt();
1084 :
1085 :
1086 :
1087 :
1088 0 : }
1089 0 : void MainRow::dataSizeFromBin(EndianIStream& eis) {
1090 :
1091 :
1092 :
1093 :
1094 :
1095 0 : dataSize = eis.readLong();
1096 :
1097 :
1098 :
1099 :
1100 0 : }
1101 0 : void MainRow::dataUIDFromBin(EndianIStream& eis) {
1102 :
1103 :
1104 :
1105 :
1106 0 : dataUID = EntityRef::fromBin(eis);
1107 :
1108 :
1109 :
1110 0 : }
1111 0 : void MainRow::stateIdFromBin(EndianIStream& eis) {
1112 :
1113 :
1114 :
1115 :
1116 :
1117 :
1118 0 : stateId = Tag::from1DBin(eis);
1119 :
1120 :
1121 :
1122 :
1123 :
1124 0 : }
1125 0 : void MainRow::execBlockIdFromBin(EndianIStream& eis) {
1126 :
1127 :
1128 :
1129 :
1130 0 : execBlockId = Tag::fromBin(eis);
1131 :
1132 :
1133 :
1134 0 : }
1135 :
1136 :
1137 :
1138 0 : MainRow* MainRow::fromBin(EndianIStream& eis, MainTable& table, const vector<string>& attributesSeq) {
1139 0 : MainRow* row = new MainRow(table);
1140 :
1141 0 : map<string, MainAttributeFromBin>::iterator iter ;
1142 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
1143 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
1144 0 : if (iter != row->fromBinMethods.end()) {
1145 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
1146 : }
1147 : else {
1148 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
1149 0 : if (functorP)
1150 0 : (*functorP)(eis);
1151 : else
1152 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "MainTable");
1153 : }
1154 :
1155 : }
1156 0 : return row;
1157 : }
1158 :
1159 : //
1160 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
1161 : // of one row.
1162 : //
1163 :
1164 : // Convert a string into an ArrayTime
1165 0 : void MainRow::timeFromText(const string & s) {
1166 :
1167 :
1168 0 : time = ASDMValuesParser::parse<ArrayTime>(s);
1169 :
1170 :
1171 0 : }
1172 :
1173 :
1174 : // Convert a string into an Tag
1175 0 : void MainRow::configDescriptionIdFromText(const string & s) {
1176 :
1177 :
1178 0 : configDescriptionId = ASDMValuesParser::parse<Tag>(s);
1179 :
1180 :
1181 0 : }
1182 :
1183 :
1184 : // Convert a string into an Tag
1185 0 : void MainRow::fieldIdFromText(const string & s) {
1186 :
1187 :
1188 0 : fieldId = ASDMValuesParser::parse<Tag>(s);
1189 :
1190 :
1191 0 : }
1192 :
1193 :
1194 : // Convert a string into an int
1195 0 : void MainRow::numAntennaFromText(const string & s) {
1196 :
1197 :
1198 0 : numAntenna = ASDMValuesParser::parse<int>(s);
1199 :
1200 :
1201 0 : }
1202 :
1203 :
1204 : // Convert a string into an TimeSampling
1205 0 : void MainRow::timeSamplingFromText(const string & s) {
1206 :
1207 :
1208 0 : timeSampling = ASDMValuesParser::parse<TimeSamplingMod::TimeSampling>(s);
1209 :
1210 :
1211 0 : }
1212 :
1213 :
1214 : // Convert a string into an Interval
1215 0 : void MainRow::intervalFromText(const string & s) {
1216 :
1217 :
1218 0 : interval = ASDMValuesParser::parse<Interval>(s);
1219 :
1220 :
1221 0 : }
1222 :
1223 :
1224 : // Convert a string into an int
1225 0 : void MainRow::numIntegrationFromText(const string & s) {
1226 :
1227 :
1228 0 : numIntegration = ASDMValuesParser::parse<int>(s);
1229 :
1230 :
1231 0 : }
1232 :
1233 :
1234 : // Convert a string into an int
1235 0 : void MainRow::scanNumberFromText(const string & s) {
1236 :
1237 :
1238 0 : scanNumber = ASDMValuesParser::parse<int>(s);
1239 :
1240 :
1241 0 : }
1242 :
1243 :
1244 : // Convert a string into an int
1245 0 : void MainRow::subscanNumberFromText(const string & s) {
1246 :
1247 :
1248 0 : subscanNumber = ASDMValuesParser::parse<int>(s);
1249 :
1250 :
1251 0 : }
1252 :
1253 :
1254 : // Convert a string into an long
1255 0 : void MainRow::dataSizeFromText(const string & s) {
1256 :
1257 :
1258 0 : dataSize = ASDMValuesParser::parse<int64_t>(s);
1259 :
1260 :
1261 0 : }
1262 :
1263 :
1264 :
1265 : // Convert a string into an Tag
1266 0 : void MainRow::stateIdFromText(const string & s) {
1267 :
1268 :
1269 0 : stateId = ASDMValuesParser::parse1D<Tag>(s);
1270 :
1271 :
1272 0 : }
1273 :
1274 :
1275 : // Convert a string into an Tag
1276 0 : void MainRow::execBlockIdFromText(const string & s) {
1277 :
1278 :
1279 0 : execBlockId = ASDMValuesParser::parse<Tag>(s);
1280 :
1281 :
1282 0 : }
1283 :
1284 :
1285 :
1286 :
1287 0 : void MainRow::fromText(const std::string& attributeName, const std::string& t) {
1288 0 : map<string, MainAttributeFromText>::iterator iter;
1289 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
1290 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "MainTable");
1291 0 : (this->*(iter->second))(t);
1292 0 : }
1293 :
1294 : ////////////////////////////////////////////////
1295 : // Intrinsic Table Attributes getters/setters //
1296 : ////////////////////////////////////////////////
1297 :
1298 :
1299 :
1300 :
1301 : /**
1302 : * Get time.
1303 : * @return time as ArrayTime
1304 : */
1305 15838 : ArrayTime MainRow::getTime() const {
1306 :
1307 15838 : return time;
1308 : }
1309 :
1310 : /**
1311 : * Set time with the specified ArrayTime.
1312 : * @param time The ArrayTime value to which time is to be set.
1313 :
1314 :
1315 :
1316 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1317 :
1318 : */
1319 8163 : void MainRow::setTime (ArrayTime time) {
1320 :
1321 :
1322 8163 : if (hasBeenAdded) {
1323 :
1324 0 : throw IllegalAccessException("time", "Main");
1325 :
1326 : }
1327 :
1328 8163 : this->time = time;
1329 :
1330 8163 : }
1331 :
1332 :
1333 :
1334 :
1335 :
1336 :
1337 : /**
1338 : * Get numAntenna.
1339 : * @return numAntenna as int
1340 : */
1341 0 : int MainRow::getNumAntenna() const {
1342 :
1343 0 : return numAntenna;
1344 : }
1345 :
1346 : /**
1347 : * Set numAntenna with the specified int.
1348 : * @param numAntenna The int value to which numAntenna is to be set.
1349 :
1350 :
1351 :
1352 : */
1353 8163 : void MainRow::setNumAntenna (int numAntenna) {
1354 :
1355 :
1356 8163 : if (hasBeenAdded) {
1357 :
1358 : }
1359 :
1360 8163 : this->numAntenna = numAntenna;
1361 :
1362 8163 : }
1363 :
1364 :
1365 :
1366 :
1367 :
1368 :
1369 : /**
1370 : * Get timeSampling.
1371 : * @return timeSampling as TimeSamplingMod::TimeSampling
1372 : */
1373 5292 : TimeSamplingMod::TimeSampling MainRow::getTimeSampling() const {
1374 :
1375 5292 : return timeSampling;
1376 : }
1377 :
1378 : /**
1379 : * Set timeSampling with the specified TimeSamplingMod::TimeSampling.
1380 : * @param timeSampling The TimeSamplingMod::TimeSampling value to which timeSampling is to be set.
1381 :
1382 :
1383 :
1384 : */
1385 536 : void MainRow::setTimeSampling (TimeSamplingMod::TimeSampling timeSampling) {
1386 :
1387 :
1388 536 : if (hasBeenAdded) {
1389 :
1390 : }
1391 :
1392 536 : this->timeSampling = timeSampling;
1393 :
1394 536 : }
1395 :
1396 :
1397 :
1398 :
1399 :
1400 :
1401 : /**
1402 : * Get interval.
1403 : * @return interval as Interval
1404 : */
1405 0 : Interval MainRow::getInterval() const {
1406 :
1407 0 : return interval;
1408 : }
1409 :
1410 : /**
1411 : * Set interval with the specified Interval.
1412 : * @param interval The Interval value to which interval is to be set.
1413 :
1414 :
1415 :
1416 : */
1417 8163 : void MainRow::setInterval (Interval interval) {
1418 :
1419 :
1420 8163 : if (hasBeenAdded) {
1421 :
1422 : }
1423 :
1424 8163 : this->interval = interval;
1425 :
1426 8163 : }
1427 :
1428 :
1429 :
1430 :
1431 :
1432 :
1433 : /**
1434 : * Get numIntegration.
1435 : * @return numIntegration as int
1436 : */
1437 3450 : int MainRow::getNumIntegration() const {
1438 :
1439 3450 : return numIntegration;
1440 : }
1441 :
1442 : /**
1443 : * Set numIntegration with the specified int.
1444 : * @param numIntegration The int value to which numIntegration is to be set.
1445 :
1446 :
1447 :
1448 : */
1449 8163 : void MainRow::setNumIntegration (int numIntegration) {
1450 :
1451 :
1452 8163 : if (hasBeenAdded) {
1453 :
1454 : }
1455 :
1456 8163 : this->numIntegration = numIntegration;
1457 :
1458 8163 : }
1459 :
1460 :
1461 :
1462 :
1463 :
1464 :
1465 : /**
1466 : * Get scanNumber.
1467 : * @return scanNumber as int
1468 : */
1469 53217 : int MainRow::getScanNumber() const {
1470 :
1471 53217 : return scanNumber;
1472 : }
1473 :
1474 : /**
1475 : * Set scanNumber with the specified int.
1476 : * @param scanNumber The int value to which scanNumber is to be set.
1477 :
1478 :
1479 :
1480 : */
1481 8163 : void MainRow::setScanNumber (int scanNumber) {
1482 :
1483 :
1484 8163 : if (hasBeenAdded) {
1485 :
1486 : }
1487 :
1488 8163 : this->scanNumber = scanNumber;
1489 :
1490 8163 : }
1491 :
1492 :
1493 :
1494 :
1495 :
1496 :
1497 : /**
1498 : * Get subscanNumber.
1499 : * @return subscanNumber as int
1500 : */
1501 14408 : int MainRow::getSubscanNumber() const {
1502 :
1503 14408 : return subscanNumber;
1504 : }
1505 :
1506 : /**
1507 : * Set subscanNumber with the specified int.
1508 : * @param subscanNumber The int value to which subscanNumber is to be set.
1509 :
1510 :
1511 :
1512 : */
1513 8163 : void MainRow::setSubscanNumber (int subscanNumber) {
1514 :
1515 :
1516 8163 : if (hasBeenAdded) {
1517 :
1518 : }
1519 :
1520 8163 : this->subscanNumber = subscanNumber;
1521 :
1522 8163 : }
1523 :
1524 :
1525 :
1526 :
1527 :
1528 :
1529 : /**
1530 : * Get dataSize.
1531 : * @return dataSize as int64_t
1532 : */
1533 4335 : int64_t MainRow::getDataSize() const {
1534 :
1535 4335 : return dataSize;
1536 : }
1537 :
1538 : /**
1539 : * Set dataSize with the specified int64_t.
1540 : * @param dataSize The int64_t value to which dataSize is to be set.
1541 :
1542 :
1543 :
1544 : */
1545 8163 : void MainRow::setDataSize (int64_t dataSize) {
1546 :
1547 :
1548 8163 : if (hasBeenAdded) {
1549 :
1550 : }
1551 :
1552 8163 : this->dataSize = dataSize;
1553 :
1554 8163 : }
1555 :
1556 :
1557 :
1558 :
1559 :
1560 :
1561 : /**
1562 : * Get dataUID.
1563 : * @return dataUID as EntityRef
1564 : */
1565 3776 : EntityRef MainRow::getDataUID() const {
1566 :
1567 3776 : return dataUID;
1568 : }
1569 :
1570 : /**
1571 : * Set dataUID with the specified EntityRef.
1572 : * @param dataUID The EntityRef value to which dataUID is to be set.
1573 :
1574 :
1575 :
1576 : */
1577 8163 : void MainRow::setDataUID (EntityRef dataUID) {
1578 :
1579 :
1580 8163 : if (hasBeenAdded) {
1581 :
1582 : }
1583 :
1584 8163 : this->dataUID = dataUID;
1585 :
1586 8163 : }
1587 :
1588 :
1589 :
1590 :
1591 : ///////////////////////////////////////////////
1592 : // Extrinsic Table Attributes getters/setters//
1593 : ///////////////////////////////////////////////
1594 :
1595 :
1596 :
1597 :
1598 : /**
1599 : * Get configDescriptionId.
1600 : * @return configDescriptionId as Tag
1601 : */
1602 6952088 : Tag MainRow::getConfigDescriptionId() const {
1603 :
1604 6952088 : return configDescriptionId;
1605 : }
1606 :
1607 : /**
1608 : * Set configDescriptionId with the specified Tag.
1609 : * @param configDescriptionId The Tag value to which configDescriptionId is to be set.
1610 :
1611 :
1612 :
1613 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1614 :
1615 : */
1616 8163 : void MainRow::setConfigDescriptionId (Tag configDescriptionId) {
1617 :
1618 :
1619 8163 : if (hasBeenAdded) {
1620 :
1621 0 : throw IllegalAccessException("configDescriptionId", "Main");
1622 :
1623 : }
1624 :
1625 8163 : this->configDescriptionId = configDescriptionId;
1626 :
1627 8163 : }
1628 :
1629 :
1630 :
1631 :
1632 :
1633 :
1634 : /**
1635 : * Get execBlockId.
1636 : * @return execBlockId as Tag
1637 : */
1638 44381 : Tag MainRow::getExecBlockId() const {
1639 :
1640 44381 : return execBlockId;
1641 : }
1642 :
1643 : /**
1644 : * Set execBlockId with the specified Tag.
1645 : * @param execBlockId The Tag value to which execBlockId is to be set.
1646 :
1647 :
1648 :
1649 : */
1650 8163 : void MainRow::setExecBlockId (Tag execBlockId) {
1651 :
1652 :
1653 8163 : if (hasBeenAdded) {
1654 :
1655 : }
1656 :
1657 8163 : this->execBlockId = execBlockId;
1658 :
1659 8163 : }
1660 :
1661 :
1662 :
1663 :
1664 :
1665 :
1666 : /**
1667 : * Get fieldId.
1668 : * @return fieldId as Tag
1669 : */
1670 9226 : Tag MainRow::getFieldId() const {
1671 :
1672 9226 : return fieldId;
1673 : }
1674 :
1675 : /**
1676 : * Set fieldId with the specified Tag.
1677 : * @param fieldId The Tag value to which fieldId is to be set.
1678 :
1679 :
1680 :
1681 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1682 :
1683 : */
1684 8163 : void MainRow::setFieldId (Tag fieldId) {
1685 :
1686 :
1687 8163 : if (hasBeenAdded) {
1688 :
1689 0 : throw IllegalAccessException("fieldId", "Main");
1690 :
1691 : }
1692 :
1693 8163 : this->fieldId = fieldId;
1694 :
1695 8163 : }
1696 :
1697 :
1698 :
1699 :
1700 :
1701 :
1702 : /**
1703 : * Get stateId.
1704 : * @return stateId as std::vector<Tag>
1705 : */
1706 0 : std::vector<Tag> MainRow::getStateId() const {
1707 :
1708 0 : return stateId;
1709 : }
1710 :
1711 : /**
1712 : * Set stateId with the specified std::vector<Tag> .
1713 : * @param stateId The std::vector<Tag> value to which stateId is to be set.
1714 :
1715 :
1716 :
1717 : */
1718 8163 : void MainRow::setStateId (std::vector<Tag> stateId) {
1719 :
1720 :
1721 8163 : if (hasBeenAdded) {
1722 :
1723 : }
1724 :
1725 8163 : this->stateId = stateId;
1726 :
1727 8163 : }
1728 :
1729 :
1730 :
1731 :
1732 : //////////////////////////////////////
1733 : // Links Attributes getters/setters //
1734 : //////////////////////////////////////
1735 :
1736 :
1737 :
1738 :
1739 :
1740 :
1741 : /**
1742 : * Returns the pointer to the row in the ConfigDescription table having ConfigDescription.configDescriptionId == configDescriptionId
1743 : * @return a ConfigDescriptionRow*
1744 : *
1745 :
1746 : */
1747 17131 : ConfigDescriptionRow* MainRow::getConfigDescriptionUsingConfigDescriptionId() {
1748 :
1749 17131 : return table.getContainer().getConfigDescription().getRowByKey(configDescriptionId);
1750 : }
1751 :
1752 :
1753 :
1754 :
1755 :
1756 :
1757 :
1758 :
1759 :
1760 : /**
1761 : * Returns the pointer to the row in the Field table having Field.fieldId == fieldId
1762 : * @return a FieldRow*
1763 : *
1764 :
1765 : */
1766 11105 : FieldRow* MainRow::getFieldUsingFieldId() {
1767 :
1768 11105 : return table.getContainer().getField().getRowByKey(fieldId);
1769 : }
1770 :
1771 :
1772 :
1773 :
1774 :
1775 :
1776 : /**
1777 : * Set stateId[i] with the specified Tag.
1778 : * @param i The index in stateId where to set the Tag value.
1779 : * @param stateId The Tag value to which stateId[i] is to be set.
1780 :
1781 : * @throws IndexOutOfBoundsException
1782 : */
1783 0 : void MainRow::setStateId (int i, Tag stateId) {
1784 0 : if (hasBeenAdded) {
1785 :
1786 : }
1787 0 : if ((i < 0) || (i > ((int) this->stateId.size())))
1788 0 : throw OutOfBoundsException("Index out of bounds during a set operation on attribute stateId in table MainTable");
1789 0 : std::vector<Tag> ::iterator iter = this->stateId.begin();
1790 0 : int j = 0;
1791 0 : while (j < i) {
1792 0 : j++; iter++;
1793 : }
1794 0 : this->stateId.insert(this->stateId.erase(iter), stateId);
1795 0 : }
1796 :
1797 :
1798 :
1799 :
1800 :
1801 : /**
1802 : * Append a Tag to stateId.
1803 : * @param id the Tag to be appended to stateId
1804 : */
1805 0 : void MainRow::addStateId(Tag id){
1806 0 : stateId.push_back(id);
1807 0 : }
1808 :
1809 : /**
1810 : * Append an array of Tag to stateId.
1811 : * @param id an array of Tag to be appended to stateId
1812 : */
1813 0 : void MainRow::addStateId(const std::vector<Tag> & id) {
1814 0 : for (unsigned int i=0; i < id.size(); i++)
1815 0 : stateId.push_back(id.at(i));
1816 0 : }
1817 :
1818 :
1819 : /**
1820 : * Returns the Tag stored in stateId at position i.
1821 : *
1822 : */
1823 0 : const Tag MainRow::getStateId(int i) {
1824 0 : return stateId.at(i);
1825 : }
1826 :
1827 : /**
1828 : * Returns the StateRow linked to this row via the Tag stored in stateId
1829 : * at position i.
1830 : */
1831 0 : StateRow* MainRow::getStateUsingStateId(int i) {
1832 0 : return table.getContainer().getState().getRowByKey(stateId.at(i));
1833 : }
1834 :
1835 : /**
1836 : * Returns the vector of StateRow* linked to this row via the Tags stored in stateId
1837 : *
1838 : */
1839 697 : vector<StateRow *> MainRow::getStatesUsingStateId() {
1840 697 : vector<StateRow *> result;
1841 9983 : for (unsigned int i = 0; i < stateId.size(); i++)
1842 9286 : result.push_back(table.getContainer().getState().getRowByKey(stateId.at(i)));
1843 :
1844 697 : return result;
1845 : }
1846 :
1847 :
1848 :
1849 :
1850 :
1851 :
1852 :
1853 :
1854 :
1855 : /**
1856 : * Returns the pointer to the row in the ExecBlock table having ExecBlock.execBlockId == execBlockId
1857 : * @return a ExecBlockRow*
1858 : *
1859 :
1860 : */
1861 5079 : ExecBlockRow* MainRow::getExecBlockUsingExecBlockId() {
1862 :
1863 5079 : return table.getContainer().getExecBlock().getRowByKey(execBlockId);
1864 : }
1865 :
1866 :
1867 :
1868 :
1869 :
1870 : /**
1871 : * Create a MainRow.
1872 : * <p>
1873 : * This constructor is private because only the
1874 : * table can create rows. All rows know the table
1875 : * to which they belong.
1876 : * @param table The table to which this row belongs.
1877 : */
1878 8163 : MainRow::MainRow (MainTable &t) : table(t) {
1879 8163 : hasBeenAdded = false;
1880 :
1881 :
1882 :
1883 :
1884 :
1885 :
1886 :
1887 :
1888 :
1889 :
1890 :
1891 :
1892 :
1893 :
1894 :
1895 :
1896 :
1897 :
1898 :
1899 :
1900 :
1901 :
1902 :
1903 :
1904 :
1905 :
1906 :
1907 :
1908 :
1909 :
1910 :
1911 :
1912 :
1913 :
1914 :
1915 :
1916 :
1917 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
1918 8163 : timeSampling = CTimeSampling::from_int(0);
1919 :
1920 :
1921 :
1922 :
1923 :
1924 :
1925 :
1926 :
1927 :
1928 :
1929 :
1930 :
1931 :
1932 :
1933 :
1934 :
1935 8163 : fromBinMethods["time"] = &MainRow::timeFromBin;
1936 8163 : fromBinMethods["configDescriptionId"] = &MainRow::configDescriptionIdFromBin;
1937 8163 : fromBinMethods["fieldId"] = &MainRow::fieldIdFromBin;
1938 8163 : fromBinMethods["numAntenna"] = &MainRow::numAntennaFromBin;
1939 8163 : fromBinMethods["timeSampling"] = &MainRow::timeSamplingFromBin;
1940 8163 : fromBinMethods["interval"] = &MainRow::intervalFromBin;
1941 8163 : fromBinMethods["numIntegration"] = &MainRow::numIntegrationFromBin;
1942 8163 : fromBinMethods["scanNumber"] = &MainRow::scanNumberFromBin;
1943 8163 : fromBinMethods["subscanNumber"] = &MainRow::subscanNumberFromBin;
1944 8163 : fromBinMethods["dataSize"] = &MainRow::dataSizeFromBin;
1945 8163 : fromBinMethods["dataUID"] = &MainRow::dataUIDFromBin;
1946 8163 : fromBinMethods["stateId"] = &MainRow::stateIdFromBin;
1947 8163 : fromBinMethods["execBlockId"] = &MainRow::execBlockIdFromBin;
1948 :
1949 :
1950 :
1951 :
1952 :
1953 :
1954 :
1955 8163 : fromTextMethods["time"] = &MainRow::timeFromText;
1956 :
1957 :
1958 :
1959 8163 : fromTextMethods["configDescriptionId"] = &MainRow::configDescriptionIdFromText;
1960 :
1961 :
1962 :
1963 8163 : fromTextMethods["fieldId"] = &MainRow::fieldIdFromText;
1964 :
1965 :
1966 :
1967 8163 : fromTextMethods["numAntenna"] = &MainRow::numAntennaFromText;
1968 :
1969 :
1970 :
1971 8163 : fromTextMethods["timeSampling"] = &MainRow::timeSamplingFromText;
1972 :
1973 :
1974 :
1975 8163 : fromTextMethods["interval"] = &MainRow::intervalFromText;
1976 :
1977 :
1978 :
1979 8163 : fromTextMethods["numIntegration"] = &MainRow::numIntegrationFromText;
1980 :
1981 :
1982 :
1983 8163 : fromTextMethods["scanNumber"] = &MainRow::scanNumberFromText;
1984 :
1985 :
1986 :
1987 8163 : fromTextMethods["subscanNumber"] = &MainRow::subscanNumberFromText;
1988 :
1989 :
1990 :
1991 8163 : fromTextMethods["dataSize"] = &MainRow::dataSizeFromText;
1992 :
1993 :
1994 :
1995 :
1996 :
1997 8163 : fromTextMethods["stateId"] = &MainRow::stateIdFromText;
1998 :
1999 :
2000 :
2001 8163 : fromTextMethods["execBlockId"] = &MainRow::execBlockIdFromText;
2002 :
2003 :
2004 :
2005 :
2006 8163 : }
2007 :
2008 0 : MainRow::MainRow (MainTable &t, MainRow *row) : table(t) {
2009 0 : hasBeenAdded = false;
2010 :
2011 0 : if (row == 0) {
2012 :
2013 :
2014 :
2015 :
2016 :
2017 :
2018 :
2019 :
2020 :
2021 :
2022 :
2023 :
2024 :
2025 :
2026 :
2027 :
2028 :
2029 :
2030 :
2031 :
2032 :
2033 :
2034 :
2035 :
2036 :
2037 :
2038 :
2039 :
2040 :
2041 : }
2042 : else {
2043 :
2044 :
2045 0 : time = row->time;
2046 :
2047 0 : configDescriptionId = row->configDescriptionId;
2048 :
2049 0 : fieldId = row->fieldId;
2050 :
2051 :
2052 :
2053 :
2054 0 : numAntenna = row->numAntenna;
2055 :
2056 0 : timeSampling = row->timeSampling;
2057 :
2058 0 : interval = row->interval;
2059 :
2060 0 : numIntegration = row->numIntegration;
2061 :
2062 0 : scanNumber = row->scanNumber;
2063 :
2064 0 : subscanNumber = row->subscanNumber;
2065 :
2066 0 : dataSize = row->dataSize;
2067 :
2068 0 : dataUID = row->dataUID;
2069 :
2070 0 : stateId = row->stateId;
2071 :
2072 0 : execBlockId = row->execBlockId;
2073 :
2074 :
2075 :
2076 :
2077 : }
2078 :
2079 0 : fromBinMethods["time"] = &MainRow::timeFromBin;
2080 0 : fromBinMethods["configDescriptionId"] = &MainRow::configDescriptionIdFromBin;
2081 0 : fromBinMethods["fieldId"] = &MainRow::fieldIdFromBin;
2082 0 : fromBinMethods["numAntenna"] = &MainRow::numAntennaFromBin;
2083 0 : fromBinMethods["timeSampling"] = &MainRow::timeSamplingFromBin;
2084 0 : fromBinMethods["interval"] = &MainRow::intervalFromBin;
2085 0 : fromBinMethods["numIntegration"] = &MainRow::numIntegrationFromBin;
2086 0 : fromBinMethods["scanNumber"] = &MainRow::scanNumberFromBin;
2087 0 : fromBinMethods["subscanNumber"] = &MainRow::subscanNumberFromBin;
2088 0 : fromBinMethods["dataSize"] = &MainRow::dataSizeFromBin;
2089 0 : fromBinMethods["dataUID"] = &MainRow::dataUIDFromBin;
2090 0 : fromBinMethods["stateId"] = &MainRow::stateIdFromBin;
2091 0 : fromBinMethods["execBlockId"] = &MainRow::execBlockIdFromBin;
2092 :
2093 :
2094 :
2095 0 : }
2096 :
2097 :
2098 0 : bool MainRow::compareNoAutoInc(ArrayTime time, Tag configDescriptionId, Tag fieldId, int numAntenna, TimeSamplingMod::TimeSampling timeSampling, Interval interval, int numIntegration, int scanNumber, int subscanNumber, int64_t dataSize, EntityRef dataUID, std::vector<Tag> stateId, Tag execBlockId) {
2099 : bool result;
2100 0 : result = true;
2101 :
2102 :
2103 :
2104 0 : result = result && (this->time == time);
2105 :
2106 0 : if (!result) return false;
2107 :
2108 :
2109 :
2110 :
2111 0 : result = result && (this->configDescriptionId == configDescriptionId);
2112 :
2113 0 : if (!result) return false;
2114 :
2115 :
2116 :
2117 :
2118 0 : result = result && (this->fieldId == fieldId);
2119 :
2120 0 : if (!result) return false;
2121 :
2122 :
2123 :
2124 :
2125 0 : result = result && (this->numAntenna == numAntenna);
2126 :
2127 0 : if (!result) return false;
2128 :
2129 :
2130 :
2131 :
2132 0 : result = result && (this->timeSampling == timeSampling);
2133 :
2134 0 : if (!result) return false;
2135 :
2136 :
2137 :
2138 :
2139 0 : result = result && (this->interval == interval);
2140 :
2141 0 : if (!result) return false;
2142 :
2143 :
2144 :
2145 :
2146 0 : result = result && (this->numIntegration == numIntegration);
2147 :
2148 0 : if (!result) return false;
2149 :
2150 :
2151 :
2152 :
2153 0 : result = result && (this->scanNumber == scanNumber);
2154 :
2155 0 : if (!result) return false;
2156 :
2157 :
2158 :
2159 :
2160 0 : result = result && (this->subscanNumber == subscanNumber);
2161 :
2162 0 : if (!result) return false;
2163 :
2164 :
2165 :
2166 :
2167 0 : result = result && (this->dataSize == dataSize);
2168 :
2169 0 : if (!result) return false;
2170 :
2171 :
2172 :
2173 :
2174 0 : result = result && (this->dataUID == dataUID);
2175 :
2176 0 : if (!result) return false;
2177 :
2178 :
2179 :
2180 :
2181 0 : result = result && (this->stateId == stateId);
2182 :
2183 0 : if (!result) return false;
2184 :
2185 :
2186 :
2187 :
2188 0 : result = result && (this->execBlockId == execBlockId);
2189 :
2190 0 : if (!result) return false;
2191 :
2192 :
2193 0 : return result;
2194 : }
2195 :
2196 :
2197 :
2198 0 : bool MainRow::compareRequiredValue(int numAntenna, TimeSamplingMod::TimeSampling timeSampling, Interval interval, int numIntegration, int scanNumber, int subscanNumber, int64_t dataSize, EntityRef dataUID, std::vector<Tag> stateId, Tag execBlockId) {
2199 : bool result;
2200 0 : result = true;
2201 :
2202 :
2203 0 : if (!(this->numAntenna == numAntenna)) return false;
2204 :
2205 :
2206 :
2207 0 : if (!(this->timeSampling == timeSampling)) return false;
2208 :
2209 :
2210 :
2211 0 : if (!(this->interval == interval)) return false;
2212 :
2213 :
2214 :
2215 0 : if (!(this->numIntegration == numIntegration)) return false;
2216 :
2217 :
2218 :
2219 0 : if (!(this->scanNumber == scanNumber)) return false;
2220 :
2221 :
2222 :
2223 0 : if (!(this->subscanNumber == subscanNumber)) return false;
2224 :
2225 :
2226 :
2227 0 : if (!(this->dataSize == dataSize)) return false;
2228 :
2229 :
2230 :
2231 0 : if (!(this->dataUID == dataUID)) return false;
2232 :
2233 :
2234 :
2235 0 : if (!(this->stateId == stateId)) return false;
2236 :
2237 :
2238 :
2239 0 : if (!(this->execBlockId == execBlockId)) return false;
2240 :
2241 :
2242 0 : return result;
2243 : }
2244 :
2245 :
2246 : /**
2247 : * Return true if all required attributes of the value part are equal to their homologues
2248 : * in x and false otherwise.
2249 : *
2250 :
2251 : * @param x a pointer on the MainRow whose required attributes of the value part
2252 :
2253 : * will be compared with those of this.
2254 : * @return a boolean.
2255 : */
2256 0 : bool MainRow::equalByRequiredValue(MainRow* x ) {
2257 :
2258 :
2259 0 : if (this->numAntenna != x->numAntenna) return false;
2260 :
2261 0 : if (this->timeSampling != x->timeSampling) return false;
2262 :
2263 0 : if (this->interval != x->interval) return false;
2264 :
2265 0 : if (this->numIntegration != x->numIntegration) return false;
2266 :
2267 0 : if (this->scanNumber != x->scanNumber) return false;
2268 :
2269 0 : if (this->subscanNumber != x->subscanNumber) return false;
2270 :
2271 0 : if (this->dataSize != x->dataSize) return false;
2272 :
2273 0 : if (this->dataUID != x->dataUID) return false;
2274 :
2275 0 : if (this->stateId != x->stateId) return false;
2276 :
2277 0 : if (this->execBlockId != x->execBlockId) return false;
2278 :
2279 :
2280 0 : return true;
2281 : }
2282 :
2283 : /*
2284 : map<string, MainAttributeFromBin> MainRow::initFromBinMethods() {
2285 : map<string, MainAttributeFromBin> result;
2286 :
2287 : result["time"] = &MainRow::timeFromBin;
2288 : result["configDescriptionId"] = &MainRow::configDescriptionIdFromBin;
2289 : result["fieldId"] = &MainRow::fieldIdFromBin;
2290 : result["numAntenna"] = &MainRow::numAntennaFromBin;
2291 : result["timeSampling"] = &MainRow::timeSamplingFromBin;
2292 : result["interval"] = &MainRow::intervalFromBin;
2293 : result["numIntegration"] = &MainRow::numIntegrationFromBin;
2294 : result["scanNumber"] = &MainRow::scanNumberFromBin;
2295 : result["subscanNumber"] = &MainRow::subscanNumberFromBin;
2296 : result["dataSize"] = &MainRow::dataSizeFromBin;
2297 : result["dataUID"] = &MainRow::dataUIDFromBin;
2298 : result["stateId"] = &MainRow::stateIdFromBin;
2299 : result["execBlockId"] = &MainRow::execBlockIdFromBin;
2300 :
2301 :
2302 :
2303 :
2304 : return result;
2305 : }
2306 : */
2307 : } // End namespace asdm
2308 :
|
