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 ObservationRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/ObservationRow.h>
39 : #include <alma/ASDM/ObservationTable.h>
40 :
41 :
42 : using asdm::ASDM;
43 : using asdm::ObservationRow;
44 : using asdm::ObservationTable;
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 : ObservationRow::~ObservationRow() {
58 0 : }
59 :
60 : /**
61 : * Return the table to which this row belongs.
62 : */
63 0 : ObservationTable &ObservationRow::getTable() const {
64 0 : return table;
65 : }
66 :
67 0 : bool ObservationRow::isAdded() const {
68 0 : return hasBeenAdded;
69 : }
70 :
71 0 : void ObservationRow::isAdded(bool added) {
72 0 : hasBeenAdded = added;
73 0 : }
74 :
75 : #ifndef WITHOUT_ACS
76 : using asdmIDL::ObservationRowIDL;
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 ObservationRowIDL struct.
83 : */
84 : ObservationRowIDL *ObservationRow::toIDL() const {
85 : ObservationRowIDL *x = new ObservationRowIDL ();
86 :
87 : // Fill the IDL structure.
88 :
89 :
90 :
91 :
92 :
93 :
94 :
95 : x->observationId = observationId.toIDLTag();
96 :
97 :
98 :
99 :
100 :
101 :
102 :
103 :
104 : return x;
105 :
106 : }
107 :
108 : void ObservationRow::toIDL(asdmIDL::ObservationRowIDL& x) const {
109 : // Set the x's fields.
110 :
111 :
112 :
113 :
114 :
115 :
116 :
117 : x.observationId = observationId.toIDLTag();
118 :
119 :
120 :
121 :
122 :
123 :
124 :
125 :
126 : }
127 : #endif
128 :
129 :
130 : #ifndef WITHOUT_ACS
131 : /**
132 : * Fill the values of this row from the IDL struct ObservationRowIDL.
133 : * @param x The IDL struct containing the values used to fill this row.
134 : */
135 : void ObservationRow::setFromIDL (ObservationRowIDL x){
136 : try {
137 : // Fill the values from x.
138 :
139 :
140 :
141 :
142 :
143 :
144 : setObservationId(Tag (x.observationId));
145 :
146 :
147 :
148 :
149 :
150 :
151 :
152 :
153 : } catch (const IllegalAccessException &err) {
154 : throw ConversionException (err.getMessage(),"Observation");
155 : }
156 : }
157 : #endif
158 :
159 : /**
160 : * Return this row in the form of an XML string.
161 : * @return The values of this row as an XML string.
162 : */
163 0 : string ObservationRow::toXML() const {
164 0 : string buf;
165 0 : buf.append("<row> \n");
166 :
167 :
168 :
169 :
170 :
171 :
172 0 : Parser::toXML(observationId, "observationId", buf);
173 :
174 :
175 :
176 :
177 :
178 :
179 :
180 :
181 0 : buf.append("</row>\n");
182 0 : return buf;
183 : }
184 :
185 : /**
186 : * Fill the values of this row from an XML string
187 : * that was produced by the toXML() method.
188 : * @param x The XML string being used to set the values of this row.
189 : */
190 0 : void ObservationRow::setFromXML (string rowDoc) {
191 0 : Parser row(rowDoc);
192 0 : string s = "";
193 : try {
194 :
195 :
196 :
197 :
198 :
199 0 : setObservationId(Parser::getTag("observationId","Observation",rowDoc));
200 :
201 :
202 :
203 :
204 :
205 :
206 :
207 0 : } catch (const IllegalAccessException &err) {
208 0 : throw ConversionException (err.getMessage(),"Observation");
209 : }
210 0 : }
211 :
212 0 : void ObservationRow::toBin(EndianOSStream& eoss) {
213 :
214 :
215 :
216 :
217 :
218 0 : observationId.toBin(eoss);
219 :
220 :
221 :
222 :
223 :
224 :
225 0 : }
226 :
227 0 : void ObservationRow::observationIdFromBin(EndianIStream& eis) {
228 :
229 :
230 :
231 :
232 0 : observationId = Tag::fromBin(eis);
233 :
234 :
235 :
236 0 : }
237 :
238 :
239 :
240 0 : ObservationRow* ObservationRow::fromBin(EndianIStream& eis, ObservationTable& table, const vector<string>& attributesSeq) {
241 0 : ObservationRow* row = new ObservationRow(table);
242 :
243 0 : map<string, ObservationAttributeFromBin>::iterator iter ;
244 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
245 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
246 0 : if (iter != row->fromBinMethods.end()) {
247 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
248 : }
249 : else {
250 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
251 0 : if (functorP)
252 0 : (*functorP)(eis);
253 : else
254 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "ObservationTable");
255 : }
256 :
257 : }
258 0 : return row;
259 : }
260 :
261 : //
262 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
263 : // of one row.
264 : //
265 :
266 : // Convert a string into an Tag
267 0 : void ObservationRow::observationIdFromText(const string & s) {
268 :
269 :
270 0 : observationId = ASDMValuesParser::parse<Tag>(s);
271 :
272 :
273 0 : }
274 :
275 :
276 :
277 :
278 0 : void ObservationRow::fromText(const std::string& attributeName, const std::string& t) {
279 0 : map<string, ObservationAttributeFromText>::iterator iter;
280 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
281 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "ObservationTable");
282 0 : (this->*(iter->second))(t);
283 0 : }
284 :
285 : ////////////////////////////////////////////////
286 : // Intrinsic Table Attributes getters/setters //
287 : ////////////////////////////////////////////////
288 :
289 :
290 :
291 :
292 : /**
293 : * Get observationId.
294 : * @return observationId as Tag
295 : */
296 0 : Tag ObservationRow::getObservationId() const {
297 :
298 0 : return observationId;
299 : }
300 :
301 : /**
302 : * Set observationId with the specified Tag.
303 : * @param observationId The Tag value to which observationId is to be set.
304 :
305 :
306 :
307 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
308 :
309 : */
310 0 : void ObservationRow::setObservationId (Tag observationId) {
311 :
312 :
313 0 : if (hasBeenAdded) {
314 :
315 0 : throw IllegalAccessException("observationId", "Observation");
316 :
317 : }
318 :
319 0 : this->observationId = observationId;
320 :
321 0 : }
322 :
323 :
324 :
325 :
326 : ///////////////////////////////////////////////
327 : // Extrinsic Table Attributes getters/setters//
328 : ///////////////////////////////////////////////
329 :
330 :
331 : //////////////////////////////////////
332 : // Links Attributes getters/setters //
333 : //////////////////////////////////////
334 :
335 :
336 : /**
337 : * Create a ObservationRow.
338 : * <p>
339 : * This constructor is private because only the
340 : * table can create rows. All rows know the table
341 : * to which they belong.
342 : * @param table The table to which this row belongs.
343 : */
344 0 : ObservationRow::ObservationRow (ObservationTable &t) : table(t) {
345 0 : hasBeenAdded = false;
346 :
347 :
348 :
349 :
350 :
351 :
352 :
353 :
354 :
355 :
356 :
357 :
358 0 : fromBinMethods["observationId"] = &ObservationRow::observationIdFromBin;
359 :
360 :
361 :
362 :
363 :
364 :
365 :
366 0 : fromTextMethods["observationId"] = &ObservationRow::observationIdFromText;
367 :
368 :
369 :
370 :
371 0 : }
372 :
373 0 : ObservationRow::ObservationRow (ObservationTable &t, ObservationRow *row) : table(t) {
374 0 : hasBeenAdded = false;
375 :
376 0 : if (row == 0) {
377 :
378 :
379 :
380 :
381 :
382 : }
383 : else {
384 :
385 :
386 0 : observationId = row->observationId;
387 :
388 :
389 :
390 :
391 :
392 :
393 :
394 : }
395 :
396 0 : fromBinMethods["observationId"] = &ObservationRow::observationIdFromBin;
397 :
398 :
399 :
400 0 : }
401 :
402 :
403 :
404 :
405 :
406 : /**
407 : * Return true if all required attributes of the value part are equal to their homologues
408 : * in x and false otherwise.
409 : *
410 :
411 : * will be compared with those of this.
412 : * @return a boolean.
413 : */
414 0 : bool ObservationRow::equalByRequiredValue(ObservationRow* ) {
415 :
416 0 : return true;
417 : }
418 :
419 : /*
420 : map<string, ObservationAttributeFromBin> ObservationRow::initFromBinMethods() {
421 : map<string, ObservationAttributeFromBin> result;
422 :
423 : result["observationId"] = &ObservationRow::observationIdFromBin;
424 :
425 :
426 :
427 :
428 : return result;
429 : }
430 : */
431 : } // End namespace asdm
432 :
|
