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