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