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