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 SwitchCycleRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/SwitchCycleRow.h>
39 : #include <alma/ASDM/SwitchCycleTable.h>
40 :
41 :
42 : using asdm::ASDM;
43 : using asdm::SwitchCycleRow;
44 : using asdm::SwitchCycleTable;
45 :
46 :
47 : #include <alma/ASDM/Parser.h>
48 :
49 : #include <alma/ASDM/EnumerationParser.h>
50 : #include <alma/ASDM/ASDMValuesParser.h>
51 :
52 : #include <alma/ASDM/InvalidArgumentException.h>
53 :
54 : using namespace std;
55 :
56 : namespace asdm {
57 184 : SwitchCycleRow::~SwitchCycleRow() {
58 184 : }
59 :
60 : /**
61 : * Return the table to which this row belongs.
62 : */
63 0 : SwitchCycleTable &SwitchCycleRow::getTable() const {
64 0 : return table;
65 : }
66 :
67 0 : bool SwitchCycleRow::isAdded() const {
68 0 : return hasBeenAdded;
69 : }
70 :
71 92 : void SwitchCycleRow::isAdded(bool added) {
72 92 : hasBeenAdded = added;
73 92 : }
74 :
75 : #ifndef WITHOUT_ACS
76 : using asdmIDL::SwitchCycleRowIDL;
77 : #endif
78 :
79 : #ifndef WITHOUT_ACS
80 : /**
81 : * Return this row in the form of an IDL struct.
82 : * @return The values of this row as a SwitchCycleRowIDL struct.
83 : */
84 : SwitchCycleRowIDL *SwitchCycleRow::toIDL() const {
85 : SwitchCycleRowIDL *x = new SwitchCycleRowIDL ();
86 :
87 : // Fill the IDL structure.
88 :
89 :
90 :
91 :
92 :
93 :
94 :
95 : x->switchCycleId = switchCycleId.toIDLTag();
96 :
97 :
98 :
99 :
100 :
101 :
102 :
103 :
104 :
105 :
106 : x->numStep = numStep;
107 :
108 :
109 :
110 :
111 :
112 :
113 :
114 :
115 :
116 :
117 : x->weightArray.length(weightArray.size());
118 : for (unsigned int i = 0; i < weightArray.size(); ++i) {
119 :
120 :
121 : x->weightArray[i] = weightArray.at(i);
122 :
123 :
124 : }
125 :
126 :
127 :
128 :
129 :
130 :
131 :
132 :
133 :
134 : x->dirOffsetArray.length(dirOffsetArray.size());
135 : for (unsigned int i = 0; i < dirOffsetArray.size(); i++) {
136 : x->dirOffsetArray[i].length(dirOffsetArray.at(i).size());
137 : }
138 :
139 : for (unsigned int i = 0; i < dirOffsetArray.size() ; i++)
140 : for (unsigned int j = 0; j < dirOffsetArray.at(i).size(); j++)
141 :
142 : x->dirOffsetArray[i][j]= dirOffsetArray.at(i).at(j).toIDLAngle();
143 :
144 :
145 :
146 :
147 :
148 :
149 :
150 :
151 :
152 :
153 :
154 : x->freqOffsetArray.length(freqOffsetArray.size());
155 : for (unsigned int i = 0; i < freqOffsetArray.size(); ++i) {
156 :
157 : x->freqOffsetArray[i] = freqOffsetArray.at(i).toIDLFrequency();
158 :
159 : }
160 :
161 :
162 :
163 :
164 :
165 :
166 :
167 :
168 :
169 : x->stepDurationArray.length(stepDurationArray.size());
170 : for (unsigned int i = 0; i < stepDurationArray.size(); ++i) {
171 :
172 : x->stepDurationArray[i] = stepDurationArray.at(i).toIDLInterval();
173 :
174 : }
175 :
176 :
177 :
178 :
179 :
180 :
181 :
182 : x->directionCodeExists = directionCodeExists;
183 :
184 :
185 :
186 :
187 : x->directionCode = directionCode;
188 :
189 :
190 :
191 :
192 :
193 :
194 :
195 :
196 : x->directionEquinoxExists = directionEquinoxExists;
197 :
198 :
199 :
200 : x->directionEquinox = directionEquinox.toIDLArrayTime();
201 :
202 :
203 :
204 :
205 :
206 :
207 :
208 :
209 : return x;
210 :
211 : }
212 :
213 : void SwitchCycleRow::toIDL(asdmIDL::SwitchCycleRowIDL& x) const {
214 : // Set the x's fields.
215 :
216 :
217 :
218 :
219 :
220 :
221 :
222 : x.switchCycleId = switchCycleId.toIDLTag();
223 :
224 :
225 :
226 :
227 :
228 :
229 :
230 :
231 :
232 :
233 : x.numStep = numStep;
234 :
235 :
236 :
237 :
238 :
239 :
240 :
241 :
242 :
243 :
244 : x.weightArray.length(weightArray.size());
245 : for (unsigned int i = 0; i < weightArray.size(); ++i) {
246 :
247 :
248 : x.weightArray[i] = weightArray.at(i);
249 :
250 :
251 : }
252 :
253 :
254 :
255 :
256 :
257 :
258 :
259 :
260 :
261 : x.dirOffsetArray.length(dirOffsetArray.size());
262 : for (unsigned int i = 0; i < dirOffsetArray.size(); i++) {
263 : x.dirOffsetArray[i].length(dirOffsetArray.at(i).size());
264 : }
265 :
266 : for (unsigned int i = 0; i < dirOffsetArray.size() ; i++)
267 : for (unsigned int j = 0; j < dirOffsetArray.at(i).size(); j++)
268 :
269 : x.dirOffsetArray[i][j]= dirOffsetArray.at(i).at(j).toIDLAngle();
270 :
271 :
272 :
273 :
274 :
275 :
276 :
277 :
278 :
279 :
280 :
281 : x.freqOffsetArray.length(freqOffsetArray.size());
282 : for (unsigned int i = 0; i < freqOffsetArray.size(); ++i) {
283 :
284 : x.freqOffsetArray[i] = freqOffsetArray.at(i).toIDLFrequency();
285 :
286 : }
287 :
288 :
289 :
290 :
291 :
292 :
293 :
294 :
295 :
296 : x.stepDurationArray.length(stepDurationArray.size());
297 : for (unsigned int i = 0; i < stepDurationArray.size(); ++i) {
298 :
299 : x.stepDurationArray[i] = stepDurationArray.at(i).toIDLInterval();
300 :
301 : }
302 :
303 :
304 :
305 :
306 :
307 :
308 :
309 : x.directionCodeExists = directionCodeExists;
310 :
311 :
312 :
313 :
314 : x.directionCode = directionCode;
315 :
316 :
317 :
318 :
319 :
320 :
321 :
322 :
323 : x.directionEquinoxExists = directionEquinoxExists;
324 :
325 :
326 :
327 : x.directionEquinox = directionEquinox.toIDLArrayTime();
328 :
329 :
330 :
331 :
332 :
333 :
334 :
335 :
336 : }
337 : #endif
338 :
339 :
340 : #ifndef WITHOUT_ACS
341 : /**
342 : * Fill the values of this row from the IDL struct SwitchCycleRowIDL.
343 : * @param x The IDL struct containing the values used to fill this row.
344 : */
345 : void SwitchCycleRow::setFromIDL (SwitchCycleRowIDL x){
346 : try {
347 : // Fill the values from x.
348 :
349 :
350 :
351 :
352 :
353 :
354 : setSwitchCycleId(Tag (x.switchCycleId));
355 :
356 :
357 :
358 :
359 :
360 :
361 :
362 :
363 :
364 : setNumStep(x.numStep);
365 :
366 :
367 :
368 :
369 :
370 :
371 :
372 :
373 :
374 : weightArray .clear();
375 : for (unsigned int i = 0; i <x.weightArray.length(); ++i) {
376 :
377 : weightArray.push_back(x.weightArray[i]);
378 :
379 : }
380 :
381 :
382 :
383 :
384 :
385 :
386 :
387 :
388 :
389 : dirOffsetArray .clear();
390 :
391 : vector<Angle> v_aux_dirOffsetArray;
392 :
393 : for (unsigned int i = 0; i < x.dirOffsetArray.length(); ++i) {
394 : v_aux_dirOffsetArray.clear();
395 : for (unsigned int j = 0; j < x.dirOffsetArray[0].length(); ++j) {
396 :
397 : v_aux_dirOffsetArray.push_back(Angle (x.dirOffsetArray[i][j]));
398 :
399 : }
400 : dirOffsetArray.push_back(v_aux_dirOffsetArray);
401 : }
402 :
403 :
404 :
405 :
406 :
407 :
408 :
409 :
410 :
411 : freqOffsetArray .clear();
412 : for (unsigned int i = 0; i <x.freqOffsetArray.length(); ++i) {
413 :
414 : freqOffsetArray.push_back(Frequency (x.freqOffsetArray[i]));
415 :
416 : }
417 :
418 :
419 :
420 :
421 :
422 :
423 :
424 :
425 :
426 : stepDurationArray .clear();
427 : for (unsigned int i = 0; i <x.stepDurationArray.length(); ++i) {
428 :
429 : stepDurationArray.push_back(Interval (x.stepDurationArray[i]));
430 :
431 : }
432 :
433 :
434 :
435 :
436 :
437 :
438 :
439 : directionCodeExists = x.directionCodeExists;
440 : if (x.directionCodeExists) {
441 :
442 :
443 :
444 : setDirectionCode(x.directionCode);
445 :
446 :
447 :
448 : }
449 :
450 :
451 :
452 :
453 :
454 : directionEquinoxExists = x.directionEquinoxExists;
455 : if (x.directionEquinoxExists) {
456 :
457 :
458 :
459 : setDirectionEquinox(ArrayTime (x.directionEquinox));
460 :
461 :
462 :
463 : }
464 :
465 :
466 :
467 :
468 :
469 :
470 : } catch (const IllegalAccessException &err) {
471 : throw ConversionException (err.getMessage(),"SwitchCycle");
472 : }
473 : }
474 : #endif
475 :
476 : /**
477 : * Return this row in the form of an XML string.
478 : * @return The values of this row as an XML string.
479 : */
480 13 : string SwitchCycleRow::toXML() const {
481 13 : string buf;
482 13 : buf.append("<row> \n");
483 :
484 :
485 :
486 :
487 :
488 :
489 13 : Parser::toXML(switchCycleId, "switchCycleId", buf);
490 :
491 :
492 :
493 :
494 :
495 :
496 :
497 13 : Parser::toXML(numStep, "numStep", buf);
498 :
499 :
500 :
501 :
502 :
503 :
504 :
505 13 : Parser::toXML(weightArray, "weightArray", buf);
506 :
507 :
508 :
509 :
510 :
511 :
512 :
513 13 : Parser::toXML(dirOffsetArray, "dirOffsetArray", buf);
514 :
515 :
516 :
517 :
518 :
519 :
520 :
521 13 : Parser::toXML(freqOffsetArray, "freqOffsetArray", buf);
522 :
523 :
524 :
525 :
526 :
527 :
528 :
529 13 : Parser::toXML(stepDurationArray, "stepDurationArray", buf);
530 :
531 :
532 :
533 :
534 :
535 :
536 13 : if (directionCodeExists) {
537 :
538 :
539 0 : buf.append(EnumerationParser::toXML("directionCode", directionCode));
540 :
541 :
542 : }
543 :
544 :
545 :
546 :
547 :
548 13 : if (directionEquinoxExists) {
549 :
550 :
551 0 : Parser::toXML(directionEquinox, "directionEquinox", buf);
552 :
553 :
554 : }
555 :
556 :
557 :
558 :
559 :
560 :
561 :
562 13 : buf.append("</row>\n");
563 13 : return buf;
564 0 : }
565 :
566 : /**
567 : * Fill the values of this row from an XML string
568 : * that was produced by the toXML() method.
569 : * @param x The XML string being used to set the values of this row.
570 : */
571 78 : void SwitchCycleRow::setFromXML (string rowDoc) {
572 78 : Parser row(rowDoc);
573 78 : string s = "";
574 : try {
575 :
576 :
577 :
578 :
579 :
580 78 : setSwitchCycleId(Parser::getTag("switchCycleId","SwitchCycle",rowDoc));
581 :
582 :
583 :
584 :
585 :
586 :
587 :
588 78 : setNumStep(Parser::getInteger("numStep","SwitchCycle",rowDoc));
589 :
590 :
591 :
592 :
593 :
594 :
595 :
596 :
597 78 : setWeightArray(Parser::get1DFloat("weightArray","SwitchCycle",rowDoc));
598 :
599 :
600 :
601 :
602 :
603 :
604 :
605 :
606 :
607 78 : setDirOffsetArray(Parser::get2DAngle("dirOffsetArray","SwitchCycle",rowDoc));
608 :
609 :
610 :
611 :
612 :
613 :
614 :
615 :
616 :
617 78 : setFreqOffsetArray(Parser::get1DFrequency("freqOffsetArray","SwitchCycle",rowDoc));
618 :
619 :
620 :
621 :
622 :
623 :
624 :
625 :
626 :
627 78 : setStepDurationArray(Parser::get1DInterval("stepDurationArray","SwitchCycle",rowDoc));
628 :
629 :
630 :
631 :
632 :
633 :
634 :
635 78 : if (row.isStr("<directionCode>")) {
636 :
637 :
638 :
639 0 : directionCode = EnumerationParser::getDirectionReferenceCode("directionCode","SwitchCycle",rowDoc);
640 :
641 :
642 :
643 0 : directionCodeExists = true;
644 : }
645 :
646 :
647 :
648 :
649 :
650 78 : if (row.isStr("<directionEquinox>")) {
651 :
652 0 : setDirectionEquinox(Parser::getArrayTime("directionEquinox","SwitchCycle",rowDoc));
653 :
654 : }
655 :
656 :
657 :
658 :
659 :
660 :
661 0 : } catch (const IllegalAccessException &err) {
662 0 : throw ConversionException (err.getMessage(),"SwitchCycle");
663 0 : }
664 78 : }
665 :
666 0 : void SwitchCycleRow::toBin(EndianOSStream& eoss) {
667 :
668 :
669 :
670 :
671 :
672 0 : switchCycleId.toBin(eoss);
673 :
674 :
675 :
676 :
677 :
678 :
679 :
680 0 : eoss.writeInt(numStep);
681 :
682 :
683 :
684 :
685 :
686 :
687 :
688 :
689 :
690 0 : eoss.writeInt((int) weightArray.size());
691 0 : for (unsigned int i = 0; i < weightArray.size(); i++)
692 :
693 0 : eoss.writeFloat(weightArray.at(i));
694 :
695 :
696 :
697 :
698 :
699 :
700 :
701 :
702 :
703 0 : Angle::toBin(dirOffsetArray, eoss);
704 :
705 :
706 :
707 :
708 :
709 :
710 0 : Frequency::toBin(freqOffsetArray, eoss);
711 :
712 :
713 :
714 :
715 :
716 :
717 0 : Interval::toBin(stepDurationArray, eoss);
718 :
719 :
720 :
721 :
722 :
723 :
724 0 : eoss.writeBoolean(directionCodeExists);
725 0 : if (directionCodeExists) {
726 :
727 :
728 :
729 :
730 :
731 0 : eoss.writeString(CDirectionReferenceCode::name(directionCode));
732 : /* eoss.writeInt(directionCode); */
733 :
734 :
735 :
736 :
737 : }
738 :
739 0 : eoss.writeBoolean(directionEquinoxExists);
740 0 : if (directionEquinoxExists) {
741 :
742 :
743 :
744 :
745 0 : directionEquinox.toBin(eoss);
746 :
747 :
748 :
749 : }
750 :
751 0 : }
752 :
753 0 : void SwitchCycleRow::switchCycleIdFromBin(EndianIStream& eis) {
754 :
755 :
756 :
757 :
758 0 : switchCycleId = Tag::fromBin(eis);
759 :
760 :
761 :
762 0 : }
763 0 : void SwitchCycleRow::numStepFromBin(EndianIStream& eis) {
764 :
765 :
766 :
767 :
768 :
769 0 : numStep = eis.readInt();
770 :
771 :
772 :
773 :
774 0 : }
775 0 : void SwitchCycleRow::weightArrayFromBin(EndianIStream& eis) {
776 :
777 :
778 :
779 :
780 :
781 :
782 0 : weightArray.clear();
783 :
784 0 : unsigned int weightArrayDim1 = eis.readInt();
785 0 : for (unsigned int i = 0 ; i < weightArrayDim1; i++)
786 :
787 0 : weightArray.push_back(eis.readFloat());
788 :
789 :
790 :
791 :
792 :
793 :
794 0 : }
795 0 : void SwitchCycleRow::dirOffsetArrayFromBin(EndianIStream& eis) {
796 :
797 :
798 :
799 :
800 :
801 :
802 0 : dirOffsetArray = Angle::from2DBin(eis);
803 :
804 :
805 :
806 :
807 :
808 0 : }
809 0 : void SwitchCycleRow::freqOffsetArrayFromBin(EndianIStream& eis) {
810 :
811 :
812 :
813 :
814 :
815 :
816 0 : freqOffsetArray = Frequency::from1DBin(eis);
817 :
818 :
819 :
820 :
821 :
822 0 : }
823 0 : void SwitchCycleRow::stepDurationArrayFromBin(EndianIStream& eis) {
824 :
825 :
826 :
827 :
828 :
829 :
830 0 : stepDurationArray = Interval::from1DBin(eis);
831 :
832 :
833 :
834 :
835 :
836 0 : }
837 :
838 0 : void SwitchCycleRow::directionCodeFromBin(EndianIStream& eis) {
839 :
840 0 : directionCodeExists = eis.readBoolean();
841 0 : if (directionCodeExists) {
842 :
843 :
844 :
845 :
846 :
847 0 : directionCode = CDirectionReferenceCode::literal(eis.readString());
848 :
849 :
850 :
851 :
852 : }
853 :
854 0 : }
855 0 : void SwitchCycleRow::directionEquinoxFromBin(EndianIStream& eis) {
856 :
857 0 : directionEquinoxExists = eis.readBoolean();
858 0 : if (directionEquinoxExists) {
859 :
860 :
861 :
862 :
863 0 : directionEquinox = ArrayTime::fromBin(eis);
864 :
865 :
866 :
867 : }
868 :
869 0 : }
870 :
871 :
872 0 : SwitchCycleRow* SwitchCycleRow::fromBin(EndianIStream& eis, SwitchCycleTable& table, const vector<string>& attributesSeq) {
873 0 : SwitchCycleRow* row = new SwitchCycleRow(table);
874 :
875 0 : map<string, SwitchCycleAttributeFromBin>::iterator iter ;
876 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
877 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
878 0 : if (iter != row->fromBinMethods.end()) {
879 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
880 : }
881 : else {
882 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
883 0 : if (functorP)
884 0 : (*functorP)(eis);
885 : else
886 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "SwitchCycleTable");
887 : }
888 :
889 : }
890 0 : return row;
891 : }
892 :
893 : //
894 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
895 : // of one row.
896 : //
897 :
898 : // Convert a string into an Tag
899 0 : void SwitchCycleRow::switchCycleIdFromText(const string & s) {
900 :
901 :
902 0 : switchCycleId = ASDMValuesParser::parse<Tag>(s);
903 :
904 :
905 0 : }
906 :
907 :
908 : // Convert a string into an int
909 0 : void SwitchCycleRow::numStepFromText(const string & s) {
910 :
911 :
912 0 : numStep = ASDMValuesParser::parse<int>(s);
913 :
914 :
915 0 : }
916 :
917 :
918 : // Convert a string into an float
919 0 : void SwitchCycleRow::weightArrayFromText(const string & s) {
920 :
921 :
922 0 : weightArray = ASDMValuesParser::parse1D<float>(s);
923 :
924 :
925 0 : }
926 :
927 :
928 : // Convert a string into an Angle
929 0 : void SwitchCycleRow::dirOffsetArrayFromText(const string & s) {
930 :
931 :
932 0 : dirOffsetArray = ASDMValuesParser::parse2D<Angle>(s);
933 :
934 :
935 0 : }
936 :
937 :
938 : // Convert a string into an Frequency
939 0 : void SwitchCycleRow::freqOffsetArrayFromText(const string & s) {
940 :
941 :
942 0 : freqOffsetArray = ASDMValuesParser::parse1D<Frequency>(s);
943 :
944 :
945 0 : }
946 :
947 :
948 : // Convert a string into an Interval
949 0 : void SwitchCycleRow::stepDurationArrayFromText(const string & s) {
950 :
951 :
952 0 : stepDurationArray = ASDMValuesParser::parse1D<Interval>(s);
953 :
954 :
955 0 : }
956 :
957 :
958 :
959 : // Convert a string into an DirectionReferenceCode
960 0 : void SwitchCycleRow::directionCodeFromText(const string & s) {
961 0 : directionCodeExists = true;
962 :
963 :
964 0 : directionCode = ASDMValuesParser::parse<DirectionReferenceCodeMod::DirectionReferenceCode>(s);
965 :
966 :
967 0 : }
968 :
969 :
970 : // Convert a string into an ArrayTime
971 0 : void SwitchCycleRow::directionEquinoxFromText(const string & s) {
972 0 : directionEquinoxExists = true;
973 :
974 :
975 0 : directionEquinox = ASDMValuesParser::parse<ArrayTime>(s);
976 :
977 :
978 0 : }
979 :
980 :
981 :
982 0 : void SwitchCycleRow::fromText(const std::string& attributeName, const std::string& t) {
983 0 : map<string, SwitchCycleAttributeFromText>::iterator iter;
984 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
985 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "SwitchCycleTable");
986 0 : (this->*(iter->second))(t);
987 0 : }
988 :
989 : ////////////////////////////////////////////////
990 : // Intrinsic Table Attributes getters/setters //
991 : ////////////////////////////////////////////////
992 :
993 :
994 :
995 :
996 : /**
997 : * Get switchCycleId.
998 : * @return switchCycleId as Tag
999 : */
1000 92 : Tag SwitchCycleRow::getSwitchCycleId() const {
1001 :
1002 92 : return switchCycleId;
1003 : }
1004 :
1005 : /**
1006 : * Set switchCycleId with the specified Tag.
1007 : * @param switchCycleId The Tag value to which switchCycleId is to be set.
1008 :
1009 :
1010 :
1011 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1012 :
1013 : */
1014 92 : void SwitchCycleRow::setSwitchCycleId (Tag switchCycleId) {
1015 :
1016 :
1017 92 : if (hasBeenAdded) {
1018 :
1019 0 : throw IllegalAccessException("switchCycleId", "SwitchCycle");
1020 :
1021 : }
1022 :
1023 92 : this->switchCycleId = switchCycleId;
1024 :
1025 92 : }
1026 :
1027 :
1028 :
1029 :
1030 :
1031 :
1032 : /**
1033 : * Get numStep.
1034 : * @return numStep as int
1035 : */
1036 2099 : int SwitchCycleRow::getNumStep() const {
1037 :
1038 2099 : return numStep;
1039 : }
1040 :
1041 : /**
1042 : * Set numStep with the specified int.
1043 : * @param numStep The int value to which numStep is to be set.
1044 :
1045 :
1046 :
1047 : */
1048 92 : void SwitchCycleRow::setNumStep (int numStep) {
1049 :
1050 :
1051 92 : if (hasBeenAdded) {
1052 :
1053 : }
1054 :
1055 92 : this->numStep = numStep;
1056 :
1057 92 : }
1058 :
1059 :
1060 :
1061 :
1062 :
1063 :
1064 : /**
1065 : * Get weightArray.
1066 : * @return weightArray as std::vector<float >
1067 : */
1068 14 : std::vector<float > SwitchCycleRow::getWeightArray() const {
1069 :
1070 14 : return weightArray;
1071 : }
1072 :
1073 : /**
1074 : * Set weightArray with the specified std::vector<float >.
1075 : * @param weightArray The std::vector<float > value to which weightArray is to be set.
1076 :
1077 :
1078 :
1079 : */
1080 92 : void SwitchCycleRow::setWeightArray (std::vector<float > weightArray) {
1081 :
1082 :
1083 92 : if (hasBeenAdded) {
1084 :
1085 : }
1086 :
1087 92 : this->weightArray = weightArray;
1088 :
1089 92 : }
1090 :
1091 :
1092 :
1093 :
1094 :
1095 :
1096 : /**
1097 : * Get dirOffsetArray.
1098 : * @return dirOffsetArray as std::vector<std::vector<Angle > >
1099 : */
1100 14 : std::vector<std::vector<Angle > > SwitchCycleRow::getDirOffsetArray() const {
1101 :
1102 14 : return dirOffsetArray;
1103 : }
1104 :
1105 : /**
1106 : * Set dirOffsetArray with the specified std::vector<std::vector<Angle > >.
1107 : * @param dirOffsetArray The std::vector<std::vector<Angle > > value to which dirOffsetArray is to be set.
1108 :
1109 :
1110 :
1111 : */
1112 92 : void SwitchCycleRow::setDirOffsetArray (std::vector<std::vector<Angle > > dirOffsetArray) {
1113 :
1114 :
1115 92 : if (hasBeenAdded) {
1116 :
1117 : }
1118 :
1119 92 : this->dirOffsetArray = dirOffsetArray;
1120 :
1121 92 : }
1122 :
1123 :
1124 :
1125 :
1126 :
1127 :
1128 : /**
1129 : * Get freqOffsetArray.
1130 : * @return freqOffsetArray as std::vector<Frequency >
1131 : */
1132 14 : std::vector<Frequency > SwitchCycleRow::getFreqOffsetArray() const {
1133 :
1134 14 : return freqOffsetArray;
1135 : }
1136 :
1137 : /**
1138 : * Set freqOffsetArray with the specified std::vector<Frequency >.
1139 : * @param freqOffsetArray The std::vector<Frequency > value to which freqOffsetArray is to be set.
1140 :
1141 :
1142 :
1143 : */
1144 92 : void SwitchCycleRow::setFreqOffsetArray (std::vector<Frequency > freqOffsetArray) {
1145 :
1146 :
1147 92 : if (hasBeenAdded) {
1148 :
1149 : }
1150 :
1151 92 : this->freqOffsetArray = freqOffsetArray;
1152 :
1153 92 : }
1154 :
1155 :
1156 :
1157 :
1158 :
1159 :
1160 : /**
1161 : * Get stepDurationArray.
1162 : * @return stepDurationArray as std::vector<Interval >
1163 : */
1164 14 : std::vector<Interval > SwitchCycleRow::getStepDurationArray() const {
1165 :
1166 14 : return stepDurationArray;
1167 : }
1168 :
1169 : /**
1170 : * Set stepDurationArray with the specified std::vector<Interval >.
1171 : * @param stepDurationArray The std::vector<Interval > value to which stepDurationArray is to be set.
1172 :
1173 :
1174 :
1175 : */
1176 92 : void SwitchCycleRow::setStepDurationArray (std::vector<Interval > stepDurationArray) {
1177 :
1178 :
1179 92 : if (hasBeenAdded) {
1180 :
1181 : }
1182 :
1183 92 : this->stepDurationArray = stepDurationArray;
1184 :
1185 92 : }
1186 :
1187 :
1188 :
1189 :
1190 : /**
1191 : * The attribute directionCode is optional. Return true if this attribute exists.
1192 : * @return true if and only if the directionCode attribute exists.
1193 : */
1194 0 : bool SwitchCycleRow::isDirectionCodeExists() const {
1195 0 : return directionCodeExists;
1196 : }
1197 :
1198 :
1199 :
1200 : /**
1201 : * Get directionCode, which is optional.
1202 : * @return directionCode as DirectionReferenceCodeMod::DirectionReferenceCode
1203 : * @throw IllegalAccessException If directionCode does not exist.
1204 : */
1205 0 : DirectionReferenceCodeMod::DirectionReferenceCode SwitchCycleRow::getDirectionCode() const {
1206 0 : if (!directionCodeExists) {
1207 0 : throw IllegalAccessException("directionCode", "SwitchCycle");
1208 : }
1209 :
1210 0 : return directionCode;
1211 : }
1212 :
1213 : /**
1214 : * Set directionCode with the specified DirectionReferenceCodeMod::DirectionReferenceCode.
1215 : * @param directionCode The DirectionReferenceCodeMod::DirectionReferenceCode value to which directionCode is to be set.
1216 :
1217 :
1218 : */
1219 0 : void SwitchCycleRow::setDirectionCode (DirectionReferenceCodeMod::DirectionReferenceCode directionCode) {
1220 :
1221 0 : this->directionCode = directionCode;
1222 :
1223 0 : directionCodeExists = true;
1224 :
1225 0 : }
1226 :
1227 :
1228 : /**
1229 : * Mark directionCode, which is an optional field, as non-existent.
1230 : */
1231 0 : void SwitchCycleRow::clearDirectionCode () {
1232 0 : directionCodeExists = false;
1233 0 : }
1234 :
1235 :
1236 :
1237 : /**
1238 : * The attribute directionEquinox is optional. Return true if this attribute exists.
1239 : * @return true if and only if the directionEquinox attribute exists.
1240 : */
1241 0 : bool SwitchCycleRow::isDirectionEquinoxExists() const {
1242 0 : return directionEquinoxExists;
1243 : }
1244 :
1245 :
1246 :
1247 : /**
1248 : * Get directionEquinox, which is optional.
1249 : * @return directionEquinox as ArrayTime
1250 : * @throw IllegalAccessException If directionEquinox does not exist.
1251 : */
1252 0 : ArrayTime SwitchCycleRow::getDirectionEquinox() const {
1253 0 : if (!directionEquinoxExists) {
1254 0 : throw IllegalAccessException("directionEquinox", "SwitchCycle");
1255 : }
1256 :
1257 0 : return directionEquinox;
1258 : }
1259 :
1260 : /**
1261 : * Set directionEquinox with the specified ArrayTime.
1262 : * @param directionEquinox The ArrayTime value to which directionEquinox is to be set.
1263 :
1264 :
1265 : */
1266 0 : void SwitchCycleRow::setDirectionEquinox (ArrayTime directionEquinox) {
1267 :
1268 0 : this->directionEquinox = directionEquinox;
1269 :
1270 0 : directionEquinoxExists = true;
1271 :
1272 0 : }
1273 :
1274 :
1275 : /**
1276 : * Mark directionEquinox, which is an optional field, as non-existent.
1277 : */
1278 0 : void SwitchCycleRow::clearDirectionEquinox () {
1279 0 : directionEquinoxExists = false;
1280 0 : }
1281 :
1282 :
1283 :
1284 : ///////////////////////////////////////////////
1285 : // Extrinsic Table Attributes getters/setters//
1286 : ///////////////////////////////////////////////
1287 :
1288 :
1289 : //////////////////////////////////////
1290 : // Links Attributes getters/setters //
1291 : //////////////////////////////////////
1292 :
1293 :
1294 : /**
1295 : * Create a SwitchCycleRow.
1296 : * <p>
1297 : * This constructor is private because only the
1298 : * table can create rows. All rows know the table
1299 : * to which they belong.
1300 : * @param table The table to which this row belongs.
1301 : */
1302 92 : SwitchCycleRow::SwitchCycleRow (SwitchCycleTable &t) : table(t) {
1303 92 : hasBeenAdded = false;
1304 :
1305 :
1306 :
1307 :
1308 :
1309 :
1310 :
1311 :
1312 :
1313 :
1314 :
1315 :
1316 :
1317 :
1318 :
1319 92 : directionCodeExists = false;
1320 :
1321 :
1322 :
1323 92 : directionEquinoxExists = false;
1324 :
1325 :
1326 :
1327 :
1328 :
1329 :
1330 :
1331 :
1332 :
1333 :
1334 :
1335 :
1336 :
1337 :
1338 :
1339 :
1340 :
1341 :
1342 :
1343 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
1344 92 : directionCode = CDirectionReferenceCode::from_int(0);
1345 :
1346 :
1347 :
1348 :
1349 :
1350 :
1351 92 : fromBinMethods["switchCycleId"] = &SwitchCycleRow::switchCycleIdFromBin;
1352 92 : fromBinMethods["numStep"] = &SwitchCycleRow::numStepFromBin;
1353 92 : fromBinMethods["weightArray"] = &SwitchCycleRow::weightArrayFromBin;
1354 92 : fromBinMethods["dirOffsetArray"] = &SwitchCycleRow::dirOffsetArrayFromBin;
1355 92 : fromBinMethods["freqOffsetArray"] = &SwitchCycleRow::freqOffsetArrayFromBin;
1356 92 : fromBinMethods["stepDurationArray"] = &SwitchCycleRow::stepDurationArrayFromBin;
1357 :
1358 :
1359 92 : fromBinMethods["directionCode"] = &SwitchCycleRow::directionCodeFromBin;
1360 92 : fromBinMethods["directionEquinox"] = &SwitchCycleRow::directionEquinoxFromBin;
1361 :
1362 :
1363 :
1364 :
1365 :
1366 92 : fromTextMethods["switchCycleId"] = &SwitchCycleRow::switchCycleIdFromText;
1367 :
1368 :
1369 :
1370 92 : fromTextMethods["numStep"] = &SwitchCycleRow::numStepFromText;
1371 :
1372 :
1373 :
1374 92 : fromTextMethods["weightArray"] = &SwitchCycleRow::weightArrayFromText;
1375 :
1376 :
1377 :
1378 92 : fromTextMethods["dirOffsetArray"] = &SwitchCycleRow::dirOffsetArrayFromText;
1379 :
1380 :
1381 :
1382 92 : fromTextMethods["freqOffsetArray"] = &SwitchCycleRow::freqOffsetArrayFromText;
1383 :
1384 :
1385 :
1386 92 : fromTextMethods["stepDurationArray"] = &SwitchCycleRow::stepDurationArrayFromText;
1387 :
1388 :
1389 :
1390 :
1391 :
1392 92 : fromTextMethods["directionCode"] = &SwitchCycleRow::directionCodeFromText;
1393 :
1394 :
1395 :
1396 92 : fromTextMethods["directionEquinox"] = &SwitchCycleRow::directionEquinoxFromText;
1397 :
1398 :
1399 92 : }
1400 :
1401 0 : SwitchCycleRow::SwitchCycleRow (SwitchCycleTable &t, SwitchCycleRow *row) : table(t) {
1402 0 : hasBeenAdded = false;
1403 :
1404 0 : if (row == 0) {
1405 :
1406 :
1407 :
1408 :
1409 :
1410 :
1411 :
1412 :
1413 :
1414 :
1415 :
1416 :
1417 :
1418 :
1419 :
1420 0 : directionCodeExists = false;
1421 :
1422 :
1423 :
1424 0 : directionEquinoxExists = false;
1425 :
1426 :
1427 :
1428 : }
1429 : else {
1430 :
1431 :
1432 0 : switchCycleId = row->switchCycleId;
1433 :
1434 :
1435 :
1436 :
1437 0 : numStep = row->numStep;
1438 :
1439 0 : weightArray = row->weightArray;
1440 :
1441 0 : dirOffsetArray = row->dirOffsetArray;
1442 :
1443 0 : freqOffsetArray = row->freqOffsetArray;
1444 :
1445 0 : stepDurationArray = row->stepDurationArray;
1446 :
1447 :
1448 :
1449 :
1450 0 : if (row->directionCodeExists) {
1451 0 : directionCode = row->directionCode;
1452 0 : directionCodeExists = true;
1453 : }
1454 : else
1455 0 : directionCodeExists = false;
1456 :
1457 0 : if (row->directionEquinoxExists) {
1458 0 : directionEquinox = row->directionEquinox;
1459 0 : directionEquinoxExists = true;
1460 : }
1461 : else
1462 0 : directionEquinoxExists = false;
1463 :
1464 : }
1465 :
1466 0 : fromBinMethods["switchCycleId"] = &SwitchCycleRow::switchCycleIdFromBin;
1467 0 : fromBinMethods["numStep"] = &SwitchCycleRow::numStepFromBin;
1468 0 : fromBinMethods["weightArray"] = &SwitchCycleRow::weightArrayFromBin;
1469 0 : fromBinMethods["dirOffsetArray"] = &SwitchCycleRow::dirOffsetArrayFromBin;
1470 0 : fromBinMethods["freqOffsetArray"] = &SwitchCycleRow::freqOffsetArrayFromBin;
1471 0 : fromBinMethods["stepDurationArray"] = &SwitchCycleRow::stepDurationArrayFromBin;
1472 :
1473 :
1474 0 : fromBinMethods["directionCode"] = &SwitchCycleRow::directionCodeFromBin;
1475 0 : fromBinMethods["directionEquinox"] = &SwitchCycleRow::directionEquinoxFromBin;
1476 :
1477 0 : }
1478 :
1479 :
1480 0 : bool SwitchCycleRow::compareNoAutoInc(int numStep, std::vector<float > weightArray, std::vector<std::vector<Angle > > dirOffsetArray, std::vector<Frequency > freqOffsetArray, std::vector<Interval > stepDurationArray) {
1481 : bool result;
1482 0 : result = true;
1483 :
1484 :
1485 :
1486 0 : result = result && (this->numStep == numStep);
1487 :
1488 0 : if (!result) return false;
1489 :
1490 :
1491 :
1492 :
1493 0 : result = result && (this->weightArray == weightArray);
1494 :
1495 0 : if (!result) return false;
1496 :
1497 :
1498 :
1499 :
1500 0 : result = result && (this->dirOffsetArray == dirOffsetArray);
1501 :
1502 0 : if (!result) return false;
1503 :
1504 :
1505 :
1506 :
1507 0 : result = result && (this->freqOffsetArray == freqOffsetArray);
1508 :
1509 0 : if (!result) return false;
1510 :
1511 :
1512 :
1513 :
1514 0 : result = result && (this->stepDurationArray == stepDurationArray);
1515 :
1516 0 : if (!result) return false;
1517 :
1518 :
1519 0 : return result;
1520 : }
1521 :
1522 :
1523 :
1524 0 : bool SwitchCycleRow::compareRequiredValue(int numStep, std::vector<float > weightArray, std::vector<std::vector<Angle > > dirOffsetArray, std::vector<Frequency > freqOffsetArray, std::vector<Interval > stepDurationArray) {
1525 : bool result;
1526 0 : result = true;
1527 :
1528 :
1529 0 : if (!(this->numStep == numStep)) return false;
1530 :
1531 :
1532 :
1533 0 : if (!(this->weightArray == weightArray)) return false;
1534 :
1535 :
1536 :
1537 0 : if (!(this->dirOffsetArray == dirOffsetArray)) return false;
1538 :
1539 :
1540 :
1541 0 : if (!(this->freqOffsetArray == freqOffsetArray)) return false;
1542 :
1543 :
1544 :
1545 0 : if (!(this->stepDurationArray == stepDurationArray)) return false;
1546 :
1547 :
1548 0 : return result;
1549 : }
1550 :
1551 :
1552 : /**
1553 : * Return true if all required attributes of the value part are equal to their homologues
1554 : * in x and false otherwise.
1555 : *
1556 :
1557 : * @param x a pointer on the SwitchCycleRow whose required attributes of the value part
1558 :
1559 : * will be compared with those of this.
1560 : * @return a boolean.
1561 : */
1562 0 : bool SwitchCycleRow::equalByRequiredValue(SwitchCycleRow* x ) {
1563 :
1564 :
1565 0 : if (this->numStep != x->numStep) return false;
1566 :
1567 0 : if (this->weightArray != x->weightArray) return false;
1568 :
1569 0 : if (this->dirOffsetArray != x->dirOffsetArray) return false;
1570 :
1571 0 : if (this->freqOffsetArray != x->freqOffsetArray) return false;
1572 :
1573 0 : if (this->stepDurationArray != x->stepDurationArray) return false;
1574 :
1575 :
1576 0 : return true;
1577 : }
1578 :
1579 : /*
1580 : map<string, SwitchCycleAttributeFromBin> SwitchCycleRow::initFromBinMethods() {
1581 : map<string, SwitchCycleAttributeFromBin> result;
1582 :
1583 : result["switchCycleId"] = &SwitchCycleRow::switchCycleIdFromBin;
1584 : result["numStep"] = &SwitchCycleRow::numStepFromBin;
1585 : result["weightArray"] = &SwitchCycleRow::weightArrayFromBin;
1586 : result["dirOffsetArray"] = &SwitchCycleRow::dirOffsetArrayFromBin;
1587 : result["freqOffsetArray"] = &SwitchCycleRow::freqOffsetArrayFromBin;
1588 : result["stepDurationArray"] = &SwitchCycleRow::stepDurationArrayFromBin;
1589 :
1590 :
1591 : result["directionCode"] = &SwitchCycleRow::directionCodeFromBin;
1592 : result["directionEquinox"] = &SwitchCycleRow::directionEquinoxFromBin;
1593 :
1594 :
1595 : return result;
1596 : }
1597 : */
1598 : } // End namespace asdm
1599 :
|
