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