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 StateRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/StateRow.h>
39 : #include <alma/ASDM/StateTable.h>
40 :
41 :
42 : using asdm::ASDM;
43 : using asdm::StateRow;
44 : using asdm::StateTable;
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 322 : StateRow::~StateRow() {
58 322 : }
59 :
60 : /**
61 : * Return the table to which this row belongs.
62 : */
63 0 : StateTable &StateRow::getTable() const {
64 0 : return table;
65 : }
66 :
67 0 : bool StateRow::isAdded() const {
68 0 : return hasBeenAdded;
69 : }
70 :
71 161 : void StateRow::isAdded(bool added) {
72 161 : hasBeenAdded = added;
73 161 : }
74 :
75 : #ifndef WITHOUT_ACS
76 : using asdmIDL::StateRowIDL;
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 StateRowIDL struct.
83 : */
84 : StateRowIDL *StateRow::toIDL() const {
85 : StateRowIDL *x = new StateRowIDL ();
86 :
87 : // Fill the IDL structure.
88 :
89 :
90 :
91 :
92 :
93 :
94 :
95 : x->stateId = stateId.toIDLTag();
96 :
97 :
98 :
99 :
100 :
101 :
102 :
103 :
104 :
105 :
106 : x->calDeviceName = calDeviceName;
107 :
108 :
109 :
110 :
111 :
112 :
113 :
114 :
115 :
116 :
117 :
118 : x->sig = sig;
119 :
120 :
121 :
122 :
123 :
124 :
125 :
126 :
127 :
128 :
129 :
130 : x->ref = ref;
131 :
132 :
133 :
134 :
135 :
136 :
137 :
138 :
139 :
140 :
141 :
142 : x->onSky = onSky;
143 :
144 :
145 :
146 :
147 :
148 :
149 :
150 :
151 : x->weightExists = weightExists;
152 :
153 :
154 :
155 :
156 : x->weight = weight;
157 :
158 :
159 :
160 :
161 :
162 :
163 :
164 :
165 :
166 : return x;
167 :
168 : }
169 :
170 : void StateRow::toIDL(asdmIDL::StateRowIDL& x) const {
171 : // Set the x's fields.
172 :
173 :
174 :
175 :
176 :
177 :
178 :
179 : x.stateId = stateId.toIDLTag();
180 :
181 :
182 :
183 :
184 :
185 :
186 :
187 :
188 :
189 :
190 : x.calDeviceName = calDeviceName;
191 :
192 :
193 :
194 :
195 :
196 :
197 :
198 :
199 :
200 :
201 :
202 : x.sig = sig;
203 :
204 :
205 :
206 :
207 :
208 :
209 :
210 :
211 :
212 :
213 :
214 : x.ref = ref;
215 :
216 :
217 :
218 :
219 :
220 :
221 :
222 :
223 :
224 :
225 :
226 : x.onSky = onSky;
227 :
228 :
229 :
230 :
231 :
232 :
233 :
234 :
235 : x.weightExists = weightExists;
236 :
237 :
238 :
239 :
240 : x.weight = weight;
241 :
242 :
243 :
244 :
245 :
246 :
247 :
248 :
249 :
250 : }
251 : #endif
252 :
253 :
254 : #ifndef WITHOUT_ACS
255 : /**
256 : * Fill the values of this row from the IDL struct StateRowIDL.
257 : * @param x The IDL struct containing the values used to fill this row.
258 : */
259 : void StateRow::setFromIDL (StateRowIDL x){
260 : try {
261 : // Fill the values from x.
262 :
263 :
264 :
265 :
266 :
267 :
268 : setStateId(Tag (x.stateId));
269 :
270 :
271 :
272 :
273 :
274 :
275 :
276 :
277 :
278 : setCalDeviceName(x.calDeviceName);
279 :
280 :
281 :
282 :
283 :
284 :
285 :
286 :
287 :
288 : setSig(x.sig);
289 :
290 :
291 :
292 :
293 :
294 :
295 :
296 :
297 :
298 : setRef(x.ref);
299 :
300 :
301 :
302 :
303 :
304 :
305 :
306 :
307 :
308 : setOnSky(x.onSky);
309 :
310 :
311 :
312 :
313 :
314 :
315 :
316 : weightExists = x.weightExists;
317 : if (x.weightExists) {
318 :
319 :
320 :
321 : setWeight(x.weight);
322 :
323 :
324 :
325 : }
326 :
327 :
328 :
329 :
330 :
331 :
332 : } catch (const IllegalAccessException &err) {
333 : throw ConversionException (err.getMessage(),"State");
334 : }
335 : }
336 : #endif
337 :
338 : /**
339 : * Return this row in the form of an XML string.
340 : * @return The values of this row as an XML string.
341 : */
342 16 : string StateRow::toXML() const {
343 16 : string buf;
344 16 : buf.append("<row> \n");
345 :
346 :
347 :
348 :
349 :
350 :
351 16 : Parser::toXML(stateId, "stateId", buf);
352 :
353 :
354 :
355 :
356 :
357 :
358 :
359 16 : buf.append(EnumerationParser::toXML("calDeviceName", calDeviceName));
360 :
361 :
362 :
363 :
364 :
365 :
366 :
367 16 : Parser::toXML(sig, "sig", buf);
368 :
369 :
370 :
371 :
372 :
373 :
374 :
375 16 : Parser::toXML(ref, "ref", buf);
376 :
377 :
378 :
379 :
380 :
381 :
382 :
383 16 : Parser::toXML(onSky, "onSky", buf);
384 :
385 :
386 :
387 :
388 :
389 :
390 16 : if (weightExists) {
391 :
392 :
393 16 : Parser::toXML(weight, "weight", buf);
394 :
395 :
396 : }
397 :
398 :
399 :
400 :
401 :
402 :
403 :
404 16 : buf.append("</row>\n");
405 16 : return buf;
406 : }
407 :
408 : /**
409 : * Fill the values of this row from an XML string
410 : * that was produced by the toXML() method.
411 : * @param x The XML string being used to set the values of this row.
412 : */
413 144 : void StateRow::setFromXML (string rowDoc) {
414 288 : Parser row(rowDoc);
415 288 : string s = "";
416 : try {
417 :
418 :
419 :
420 :
421 :
422 144 : setStateId(Parser::getTag("stateId","State",rowDoc));
423 :
424 :
425 :
426 :
427 :
428 :
429 :
430 :
431 144 : calDeviceName = EnumerationParser::getCalibrationDevice("calDeviceName","State",rowDoc);
432 :
433 :
434 :
435 :
436 :
437 :
438 :
439 :
440 144 : setSig(Parser::getBoolean("sig","State",rowDoc));
441 :
442 :
443 :
444 :
445 :
446 :
447 :
448 144 : setRef(Parser::getBoolean("ref","State",rowDoc));
449 :
450 :
451 :
452 :
453 :
454 :
455 :
456 144 : setOnSky(Parser::getBoolean("onSky","State",rowDoc));
457 :
458 :
459 :
460 :
461 :
462 :
463 144 : if (row.isStr("<weight>")) {
464 :
465 115 : setWeight(Parser::getFloat("weight","State",rowDoc));
466 :
467 : }
468 :
469 :
470 :
471 :
472 :
473 :
474 0 : } catch (const IllegalAccessException &err) {
475 0 : throw ConversionException (err.getMessage(),"State");
476 : }
477 144 : }
478 :
479 0 : void StateRow::toBin(EndianOSStream& eoss) {
480 :
481 :
482 :
483 :
484 :
485 0 : stateId.toBin(eoss);
486 :
487 :
488 :
489 :
490 :
491 :
492 :
493 0 : eoss.writeString(CCalibrationDevice::name(calDeviceName));
494 : /* eoss.writeInt(calDeviceName); */
495 :
496 :
497 :
498 :
499 :
500 :
501 :
502 :
503 0 : eoss.writeBoolean(sig);
504 :
505 :
506 :
507 :
508 :
509 :
510 :
511 :
512 0 : eoss.writeBoolean(ref);
513 :
514 :
515 :
516 :
517 :
518 :
519 :
520 :
521 0 : eoss.writeBoolean(onSky);
522 :
523 :
524 :
525 :
526 :
527 :
528 :
529 0 : eoss.writeBoolean(weightExists);
530 0 : if (weightExists) {
531 :
532 :
533 :
534 :
535 :
536 0 : eoss.writeFloat(weight);
537 :
538 :
539 :
540 :
541 : }
542 :
543 0 : }
544 :
545 0 : void StateRow::stateIdFromBin(EndianIStream& eis) {
546 :
547 :
548 :
549 :
550 0 : stateId = Tag::fromBin(eis);
551 :
552 :
553 :
554 0 : }
555 0 : void StateRow::calDeviceNameFromBin(EndianIStream& eis) {
556 :
557 :
558 :
559 :
560 :
561 0 : calDeviceName = CCalibrationDevice::literal(eis.readString());
562 :
563 :
564 :
565 :
566 0 : }
567 0 : void StateRow::sigFromBin(EndianIStream& eis) {
568 :
569 :
570 :
571 :
572 :
573 0 : sig = eis.readBoolean();
574 :
575 :
576 :
577 :
578 0 : }
579 0 : void StateRow::refFromBin(EndianIStream& eis) {
580 :
581 :
582 :
583 :
584 :
585 0 : ref = eis.readBoolean();
586 :
587 :
588 :
589 :
590 0 : }
591 0 : void StateRow::onSkyFromBin(EndianIStream& eis) {
592 :
593 :
594 :
595 :
596 :
597 0 : onSky = eis.readBoolean();
598 :
599 :
600 :
601 :
602 0 : }
603 :
604 0 : void StateRow::weightFromBin(EndianIStream& eis) {
605 :
606 0 : weightExists = eis.readBoolean();
607 0 : if (weightExists) {
608 :
609 :
610 :
611 :
612 :
613 0 : weight = eis.readFloat();
614 :
615 :
616 :
617 :
618 : }
619 :
620 0 : }
621 :
622 :
623 0 : StateRow* StateRow::fromBin(EndianIStream& eis, StateTable& table, const vector<string>& attributesSeq) {
624 0 : StateRow* row = new StateRow(table);
625 :
626 0 : map<string, StateAttributeFromBin>::iterator iter ;
627 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
628 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
629 0 : if (iter != row->fromBinMethods.end()) {
630 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
631 : }
632 : else {
633 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
634 0 : if (functorP)
635 0 : (*functorP)(eis);
636 : else
637 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "StateTable");
638 : }
639 :
640 : }
641 0 : return row;
642 : }
643 :
644 : //
645 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
646 : // of one row.
647 : //
648 :
649 : // Convert a string into an Tag
650 0 : void StateRow::stateIdFromText(const string & s) {
651 :
652 :
653 0 : stateId = ASDMValuesParser::parse<Tag>(s);
654 :
655 :
656 0 : }
657 :
658 :
659 : // Convert a string into an CalibrationDevice
660 0 : void StateRow::calDeviceNameFromText(const string & s) {
661 :
662 :
663 0 : calDeviceName = ASDMValuesParser::parse<CalibrationDeviceMod::CalibrationDevice>(s);
664 :
665 :
666 0 : }
667 :
668 :
669 : // Convert a string into an boolean
670 0 : void StateRow::sigFromText(const string & s) {
671 :
672 :
673 0 : sig = ASDMValuesParser::parse<bool>(s);
674 :
675 :
676 0 : }
677 :
678 :
679 : // Convert a string into an boolean
680 0 : void StateRow::refFromText(const string & s) {
681 :
682 :
683 0 : ref = ASDMValuesParser::parse<bool>(s);
684 :
685 :
686 0 : }
687 :
688 :
689 : // Convert a string into an boolean
690 0 : void StateRow::onSkyFromText(const string & s) {
691 :
692 :
693 0 : onSky = ASDMValuesParser::parse<bool>(s);
694 :
695 :
696 0 : }
697 :
698 :
699 :
700 : // Convert a string into an float
701 0 : void StateRow::weightFromText(const string & s) {
702 0 : weightExists = true;
703 :
704 :
705 0 : weight = ASDMValuesParser::parse<float>(s);
706 :
707 :
708 0 : }
709 :
710 :
711 :
712 0 : void StateRow::fromText(const std::string& attributeName, const std::string& t) {
713 0 : map<string, StateAttributeFromText>::iterator iter;
714 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
715 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "StateTable");
716 0 : (this->*(iter->second))(t);
717 0 : }
718 :
719 : ////////////////////////////////////////////////
720 : // Intrinsic Table Attributes getters/setters //
721 : ////////////////////////////////////////////////
722 :
723 :
724 :
725 :
726 : /**
727 : * Get stateId.
728 : * @return stateId as Tag
729 : */
730 41069 : Tag StateRow::getStateId() const {
731 :
732 41069 : return stateId;
733 : }
734 :
735 : /**
736 : * Set stateId with the specified Tag.
737 : * @param stateId The Tag value to which stateId is to be set.
738 :
739 :
740 :
741 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
742 :
743 : */
744 161 : void StateRow::setStateId (Tag stateId) {
745 :
746 :
747 161 : if (hasBeenAdded) {
748 :
749 0 : throw IllegalAccessException("stateId", "State");
750 :
751 : }
752 :
753 161 : this->stateId = stateId;
754 :
755 161 : }
756 :
757 :
758 :
759 :
760 :
761 :
762 : /**
763 : * Get calDeviceName.
764 : * @return calDeviceName as CalibrationDeviceMod::CalibrationDevice
765 : */
766 23 : CalibrationDeviceMod::CalibrationDevice StateRow::getCalDeviceName() const {
767 :
768 23 : return calDeviceName;
769 : }
770 :
771 : /**
772 : * Set calDeviceName with the specified CalibrationDeviceMod::CalibrationDevice.
773 : * @param calDeviceName The CalibrationDeviceMod::CalibrationDevice value to which calDeviceName is to be set.
774 :
775 :
776 :
777 : */
778 23 : void StateRow::setCalDeviceName (CalibrationDeviceMod::CalibrationDevice calDeviceName) {
779 :
780 :
781 23 : if (hasBeenAdded) {
782 :
783 : }
784 :
785 23 : this->calDeviceName = calDeviceName;
786 :
787 23 : }
788 :
789 :
790 :
791 :
792 :
793 :
794 : /**
795 : * Get sig.
796 : * @return sig as bool
797 : */
798 4951 : bool StateRow::getSig() const {
799 :
800 4951 : return sig;
801 : }
802 :
803 : /**
804 : * Set sig with the specified bool.
805 : * @param sig The bool value to which sig is to be set.
806 :
807 :
808 :
809 : */
810 167 : void StateRow::setSig (bool sig) {
811 :
812 :
813 167 : if (hasBeenAdded) {
814 :
815 : }
816 :
817 167 : this->sig = sig;
818 :
819 167 : }
820 :
821 :
822 :
823 :
824 :
825 :
826 : /**
827 : * Get ref.
828 : * @return ref as bool
829 : */
830 4951 : bool StateRow::getRef() const {
831 :
832 4951 : return ref;
833 : }
834 :
835 : /**
836 : * Set ref with the specified bool.
837 : * @param ref The bool value to which ref is to be set.
838 :
839 :
840 :
841 : */
842 167 : void StateRow::setRef (bool ref) {
843 :
844 :
845 167 : if (hasBeenAdded) {
846 :
847 : }
848 :
849 167 : this->ref = ref;
850 :
851 167 : }
852 :
853 :
854 :
855 :
856 :
857 :
858 : /**
859 : * Get onSky.
860 : * @return onSky as bool
861 : */
862 23 : bool StateRow::getOnSky() const {
863 :
864 23 : return onSky;
865 : }
866 :
867 : /**
868 : * Set onSky with the specified bool.
869 : * @param onSky The bool value to which onSky is to be set.
870 :
871 :
872 :
873 : */
874 167 : void StateRow::setOnSky (bool onSky) {
875 :
876 :
877 167 : if (hasBeenAdded) {
878 :
879 : }
880 :
881 167 : this->onSky = onSky;
882 :
883 167 : }
884 :
885 :
886 :
887 :
888 : /**
889 : * The attribute weight is optional. Return true if this attribute exists.
890 : * @return true if and only if the weight attribute exists.
891 : */
892 0 : bool StateRow::isWeightExists() const {
893 0 : return weightExists;
894 : }
895 :
896 :
897 :
898 : /**
899 : * Get weight, which is optional.
900 : * @return weight as float
901 : * @throw IllegalAccessException If weight does not exist.
902 : */
903 0 : float StateRow::getWeight() const {
904 0 : if (!weightExists) {
905 0 : throw IllegalAccessException("weight", "State");
906 : }
907 :
908 0 : return weight;
909 : }
910 :
911 : /**
912 : * Set weight with the specified float.
913 : * @param weight The float value to which weight is to be set.
914 :
915 :
916 : */
917 138 : void StateRow::setWeight (float weight) {
918 :
919 138 : this->weight = weight;
920 :
921 138 : weightExists = true;
922 :
923 138 : }
924 :
925 :
926 : /**
927 : * Mark weight, which is an optional field, as non-existent.
928 : */
929 0 : void StateRow::clearWeight () {
930 0 : weightExists = false;
931 0 : }
932 :
933 :
934 :
935 : ///////////////////////////////////////////////
936 : // Extrinsic Table Attributes getters/setters//
937 : ///////////////////////////////////////////////
938 :
939 :
940 : //////////////////////////////////////
941 : // Links Attributes getters/setters //
942 : //////////////////////////////////////
943 :
944 :
945 : /**
946 : * Create a StateRow.
947 : * <p>
948 : * This constructor is private because only the
949 : * table can create rows. All rows know the table
950 : * to which they belong.
951 : * @param table The table to which this row belongs.
952 : */
953 167 : StateRow::StateRow (StateTable &t) : table(t) {
954 167 : hasBeenAdded = false;
955 :
956 :
957 :
958 :
959 :
960 :
961 :
962 :
963 :
964 :
965 :
966 :
967 :
968 167 : weightExists = false;
969 :
970 :
971 :
972 :
973 :
974 :
975 :
976 :
977 :
978 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
979 167 : calDeviceName = CCalibrationDevice::from_int(0);
980 :
981 :
982 :
983 :
984 :
985 :
986 :
987 :
988 :
989 :
990 :
991 :
992 167 : fromBinMethods["stateId"] = &StateRow::stateIdFromBin;
993 167 : fromBinMethods["calDeviceName"] = &StateRow::calDeviceNameFromBin;
994 167 : fromBinMethods["sig"] = &StateRow::sigFromBin;
995 167 : fromBinMethods["ref"] = &StateRow::refFromBin;
996 167 : fromBinMethods["onSky"] = &StateRow::onSkyFromBin;
997 :
998 :
999 167 : fromBinMethods["weight"] = &StateRow::weightFromBin;
1000 :
1001 :
1002 :
1003 :
1004 :
1005 167 : fromTextMethods["stateId"] = &StateRow::stateIdFromText;
1006 :
1007 :
1008 :
1009 167 : fromTextMethods["calDeviceName"] = &StateRow::calDeviceNameFromText;
1010 :
1011 :
1012 :
1013 167 : fromTextMethods["sig"] = &StateRow::sigFromText;
1014 :
1015 :
1016 :
1017 167 : fromTextMethods["ref"] = &StateRow::refFromText;
1018 :
1019 :
1020 :
1021 167 : fromTextMethods["onSky"] = &StateRow::onSkyFromText;
1022 :
1023 :
1024 :
1025 :
1026 :
1027 167 : fromTextMethods["weight"] = &StateRow::weightFromText;
1028 :
1029 :
1030 167 : }
1031 :
1032 0 : StateRow::StateRow (StateTable &t, StateRow *row) : table(t) {
1033 0 : hasBeenAdded = false;
1034 :
1035 0 : if (row == 0) {
1036 :
1037 :
1038 :
1039 :
1040 :
1041 :
1042 :
1043 :
1044 :
1045 :
1046 :
1047 :
1048 :
1049 0 : weightExists = false;
1050 :
1051 :
1052 :
1053 : }
1054 : else {
1055 :
1056 :
1057 0 : stateId = row->stateId;
1058 :
1059 :
1060 :
1061 :
1062 0 : calDeviceName = row->calDeviceName;
1063 :
1064 0 : sig = row->sig;
1065 :
1066 0 : ref = row->ref;
1067 :
1068 0 : onSky = row->onSky;
1069 :
1070 :
1071 :
1072 :
1073 0 : if (row->weightExists) {
1074 0 : weight = row->weight;
1075 0 : weightExists = true;
1076 : }
1077 : else
1078 0 : weightExists = false;
1079 :
1080 : }
1081 :
1082 0 : fromBinMethods["stateId"] = &StateRow::stateIdFromBin;
1083 0 : fromBinMethods["calDeviceName"] = &StateRow::calDeviceNameFromBin;
1084 0 : fromBinMethods["sig"] = &StateRow::sigFromBin;
1085 0 : fromBinMethods["ref"] = &StateRow::refFromBin;
1086 0 : fromBinMethods["onSky"] = &StateRow::onSkyFromBin;
1087 :
1088 :
1089 0 : fromBinMethods["weight"] = &StateRow::weightFromBin;
1090 :
1091 0 : }
1092 :
1093 :
1094 12 : bool StateRow::compareNoAutoInc(CalibrationDeviceMod::CalibrationDevice calDeviceName, bool sig, bool ref, bool onSky) {
1095 : bool result;
1096 12 : result = true;
1097 :
1098 :
1099 :
1100 12 : result = result && (this->calDeviceName == calDeviceName);
1101 :
1102 12 : if (!result) return false;
1103 :
1104 :
1105 :
1106 :
1107 12 : result = result && (this->sig == sig);
1108 :
1109 12 : if (!result) return false;
1110 :
1111 :
1112 :
1113 :
1114 6 : result = result && (this->ref == ref);
1115 :
1116 6 : if (!result) return false;
1117 :
1118 :
1119 :
1120 :
1121 6 : result = result && (this->onSky == onSky);
1122 :
1123 6 : if (!result) return false;
1124 :
1125 :
1126 6 : return result;
1127 : }
1128 :
1129 :
1130 :
1131 0 : bool StateRow::compareRequiredValue(CalibrationDeviceMod::CalibrationDevice calDeviceName, bool sig, bool ref, bool onSky) {
1132 : bool result;
1133 0 : result = true;
1134 :
1135 :
1136 0 : if (!(this->calDeviceName == calDeviceName)) return false;
1137 :
1138 :
1139 :
1140 0 : if (!(this->sig == sig)) return false;
1141 :
1142 :
1143 :
1144 0 : if (!(this->ref == ref)) return false;
1145 :
1146 :
1147 :
1148 0 : if (!(this->onSky == onSky)) return false;
1149 :
1150 :
1151 0 : return result;
1152 : }
1153 :
1154 :
1155 : /**
1156 : * Return true if all required attributes of the value part are equal to their homologues
1157 : * in x and false otherwise.
1158 : *
1159 :
1160 : * @param x a pointer on the StateRow whose required attributes of the value part
1161 :
1162 : * will be compared with those of this.
1163 : * @return a boolean.
1164 : */
1165 0 : bool StateRow::equalByRequiredValue(StateRow* x ) {
1166 :
1167 :
1168 0 : if (this->calDeviceName != x->calDeviceName) return false;
1169 :
1170 0 : if (this->sig != x->sig) return false;
1171 :
1172 0 : if (this->ref != x->ref) return false;
1173 :
1174 0 : if (this->onSky != x->onSky) return false;
1175 :
1176 :
1177 0 : return true;
1178 : }
1179 :
1180 : /*
1181 : map<string, StateAttributeFromBin> StateRow::initFromBinMethods() {
1182 : map<string, StateAttributeFromBin> result;
1183 :
1184 : result["stateId"] = &StateRow::stateIdFromBin;
1185 : result["calDeviceName"] = &StateRow::calDeviceNameFromBin;
1186 : result["sig"] = &StateRow::sigFromBin;
1187 : result["ref"] = &StateRow::refFromBin;
1188 : result["onSky"] = &StateRow::onSkyFromBin;
1189 :
1190 :
1191 : result["weight"] = &StateRow::weightFromBin;
1192 :
1193 :
1194 : return result;
1195 : }
1196 : */
1197 : } // End namespace asdm
1198 :
|
