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 CalPrimaryBeamTable.h
32 : */
33 :
34 : #ifndef CalPrimaryBeamTable_CLASS
35 : #define CalPrimaryBeamTable_CLASS
36 :
37 : #include <string>
38 : #include <vector>
39 : #include <map>
40 :
41 :
42 :
43 :
44 : #include <alma/ASDM/Angle.h>
45 :
46 :
47 :
48 : #include <alma/ASDM/ArrayTime.h>
49 :
50 :
51 :
52 : #include <alma/ASDM/Frequency.h>
53 :
54 :
55 :
56 : #include <alma/ASDM/Tag.h>
57 :
58 :
59 :
60 : #include <alma/ASDM/EntityRef.h>
61 :
62 :
63 :
64 :
65 :
66 :
67 :
68 :
69 : #include <alma/Enumerations/CReceiverBand.h>
70 :
71 :
72 :
73 :
74 :
75 :
76 :
77 : #include <alma/Enumerations/CAntennaMake.h>
78 :
79 :
80 :
81 :
82 :
83 :
84 :
85 :
86 :
87 : #include <alma/Enumerations/CPolarizationType.h>
88 :
89 :
90 :
91 :
92 :
93 :
94 :
95 :
96 :
97 :
98 :
99 :
100 :
101 :
102 :
103 : #include <alma/Enumerations/CPrimaryBeamDescription.h>
104 :
105 :
106 :
107 :
108 :
109 :
110 :
111 :
112 : #include <alma/ASDM/ConversionException.h>
113 : #include <alma/ASDM/DuplicateKey.h>
114 : #include <alma/ASDM/UniquenessViolationException.h>
115 : #include <alma/ASDM/NoSuchRow.h>
116 : #include <alma/ASDM/DuplicateKey.h>
117 :
118 :
119 : #ifndef WITHOUT_ACS
120 : #include <asdmIDLC.h>
121 : #endif
122 :
123 : #include <alma/ASDM/Representable.h>
124 :
125 : #include <pthread.h>
126 :
127 : namespace asdm {
128 :
129 : //class asdm::ASDM;
130 : //class asdm::CalPrimaryBeamRow;
131 :
132 : class ASDM;
133 : class CalPrimaryBeamRow;
134 : /**
135 : * The CalPrimaryBeamTable class is an Alma table.
136 : * <BR>
137 : *
138 : * \par Role
139 : * Result of Primary Beam Map measurement.
140 : * <BR>
141 :
142 : * Generated from model's revision "-1", branch ""
143 : *
144 : * <TABLE BORDER="1">
145 : * <CAPTION> Attributes of CalPrimaryBeam </CAPTION>
146 : * <TR BGCOLOR="#AAAAAA"> <TH> Name </TH> <TH> Type </TH> <TH> Expected shape </TH> <TH> Comment </TH></TR>
147 :
148 : * <TR> <TH BGCOLOR="#CCCCCC" colspan="4" align="center"> Key </TD></TR>
149 :
150 : * <TR>
151 :
152 : * <TD> antennaName </TD>
153 :
154 : * <TD> std::string</TD>
155 : * <TD> </TD>
156 : * <TD> the name of the antenna. </TD>
157 : * </TR>
158 :
159 : * <TR>
160 :
161 : * <TD> receiverBand </TD>
162 :
163 : * <TD> ReceiverBandMod::ReceiverBand</TD>
164 : * <TD> </TD>
165 : * <TD> identifies the receiver band. </TD>
166 : * </TR>
167 :
168 : * <TR>
169 :
170 : * <TD> calDataId </TD>
171 :
172 : * <TD> Tag</TD>
173 : * <TD> </TD>
174 : * <TD> refers to a unique row in CalData Table. </TD>
175 : * </TR>
176 :
177 : * <TR>
178 :
179 : * <TD> calReductionId </TD>
180 :
181 : * <TD> Tag</TD>
182 : * <TD> </TD>
183 : * <TD> refers to a unique row in CalReduction Table. </TD>
184 : * </TR>
185 :
186 :
187 :
188 : * <TR> <TH BGCOLOR="#CCCCCC" colspan="4" valign="center"> Value <br> (Mandatory) </TH></TR>
189 :
190 : * <TR>
191 : * <TD> startValidTime </TD>
192 : * <TD> ArrayTime </TD>
193 : * <TD> </TD>
194 : * <TD> the start time of result validity period. </TD>
195 : * </TR>
196 :
197 : * <TR>
198 : * <TD> endValidTime </TD>
199 : * <TD> ArrayTime </TD>
200 : * <TD> </TD>
201 : * <TD> the end time of result validity period. </TD>
202 : * </TR>
203 :
204 : * <TR>
205 : * <TD> antennaMake </TD>
206 : * <TD> AntennaMakeMod::AntennaMake </TD>
207 : * <TD> </TD>
208 : * <TD> the antenna make. </TD>
209 : * </TR>
210 :
211 : * <TR>
212 : * <TD> numSubband (numSubband)</TD>
213 : * <TD> int </TD>
214 : * <TD> </TD>
215 : * <TD> the number of subband images (frequency ranges simultaneously measured ). </TD>
216 : * </TR>
217 :
218 : * <TR>
219 : * <TD> frequencyRange </TD>
220 : * <TD> std::vector<std::vector<Frequency > > </TD>
221 : * <TD> numSubband, 2 </TD>
222 : * <TD> the range of frequencies over which the result is valid. </TD>
223 : * </TR>
224 :
225 : * <TR>
226 : * <TD> numReceptor (numReceptor)</TD>
227 : * <TD> int </TD>
228 : * <TD> </TD>
229 : * <TD> the number of receptors. </TD>
230 : * </TR>
231 :
232 : * <TR>
233 : * <TD> polarizationTypes </TD>
234 : * <TD> std::vector<PolarizationTypeMod::PolarizationType > </TD>
235 : * <TD> numReceptor </TD>
236 : * <TD> identifies the polarizations types of the receptors (one value per receptor). </TD>
237 : * </TR>
238 :
239 : * <TR>
240 : * <TD> mainBeamEfficiency </TD>
241 : * <TD> std::vector<double > </TD>
242 : * <TD> numReceptor </TD>
243 : * <TD> the main beam efficiency as derived from the beam map. </TD>
244 : * </TR>
245 :
246 : * <TR>
247 : * <TD> beamDescriptionUID </TD>
248 : * <TD> EntityRef </TD>
249 : * <TD> </TD>
250 : * <TD> refers to the beam description image. </TD>
251 : * </TR>
252 :
253 : * <TR>
254 : * <TD> relativeAmplitudeRms </TD>
255 : * <TD> float </TD>
256 : * <TD> </TD>
257 : * <TD> the RMS fluctuations in terms of the relative beam amplitude. </TD>
258 : * </TR>
259 :
260 : * <TR>
261 : * <TD> direction </TD>
262 : * <TD> std::vector<Angle > </TD>
263 : * <TD> 2 </TD>
264 : * <TD> the center direction. </TD>
265 : * </TR>
266 :
267 : * <TR>
268 : * <TD> minValidDirection </TD>
269 : * <TD> std::vector<Angle > </TD>
270 : * <TD> 2 </TD>
271 : * <TD> the minimum center direction of validity. </TD>
272 : * </TR>
273 :
274 : * <TR>
275 : * <TD> maxValidDirection </TD>
276 : * <TD> std::vector<Angle > </TD>
277 : * <TD> 2 </TD>
278 : * <TD> the maximum center direction of validity. </TD>
279 : * </TR>
280 :
281 : * <TR>
282 : * <TD> descriptionType </TD>
283 : * <TD> PrimaryBeamDescriptionMod::PrimaryBeamDescription </TD>
284 : * <TD> </TD>
285 : * <TD> quantity used to describe beam. </TD>
286 : * </TR>
287 :
288 : * <TR>
289 : * <TD> imageChannelNumber </TD>
290 : * <TD> std::vector<int > </TD>
291 : * <TD> numSubband </TD>
292 : * <TD> channel number in image for each subband. </TD>
293 : * </TR>
294 :
295 : * <TR>
296 : * <TD> imageNominalFrequency </TD>
297 : * <TD> std::vector<Frequency > </TD>
298 : * <TD> numSubband </TD>
299 : * <TD> nominal frequency for subband. </TD>
300 : * </TR>
301 :
302 :
303 :
304 : * </TABLE>
305 : */
306 : class CalPrimaryBeamTable : public Representable {
307 : friend class ASDM;
308 :
309 : public:
310 :
311 :
312 : /**
313 : * Return the list of field names that make up key key
314 : * as an array of strings.
315 : * @return a vector of string.
316 : */
317 : static const std::vector<std::string>& getKeyName();
318 :
319 :
320 : virtual ~CalPrimaryBeamTable();
321 :
322 : /**
323 : * Return the container to which this table belongs.
324 : *
325 : * @return the ASDM containing this table.
326 : */
327 : ASDM &getContainer() const;
328 :
329 : /**
330 : * Return the number of rows in the table.
331 : *
332 : * @return the number of rows in an unsigned int.
333 : */
334 : unsigned int size() const;
335 :
336 : /**
337 : * Return the name of this table.
338 : *
339 : * This is a instance method of the class.
340 : *
341 : * @return the name of this table in a string.
342 : */
343 : std::string getName() const;
344 :
345 : /**
346 : * Return the name of this table.
347 : *
348 : * This is a static method of the class.
349 : *
350 : * @return the name of this table in a string.
351 : */
352 : static std::string name() ;
353 :
354 : /**
355 : * Return the version information about this table.
356 : *
357 : */
358 : std::string getVersion() const ;
359 :
360 : /**
361 : * Return the names of the attributes of this table.
362 : *
363 : * @return a vector of string
364 : */
365 : static const std::vector<std::string>& getAttributesNames();
366 :
367 : /**
368 : * Return the default sorted list of attributes names in the binary representation of the table.
369 : *
370 : * @return a const reference to a vector of string
371 : */
372 : static const std::vector<std::string>& defaultAttributesNamesInBin();
373 :
374 : /**
375 : * Return this table's Entity.
376 : */
377 : Entity getEntity() const;
378 :
379 : /**
380 : * Set this table's Entity.
381 : * @param e An entity.
382 : */
383 : void setEntity(Entity e);
384 :
385 : /**
386 : * Produces an XML representation conform
387 : * to the schema defined for CalPrimaryBeam (CalPrimaryBeamTable.xsd).
388 : *
389 : * @returns a string containing the XML representation.
390 : * @throws ConversionException
391 : */
392 : std::string toXML() ;
393 :
394 : #ifndef WITHOUT_ACS
395 : // Conversion Methods
396 : /**
397 : * Convert this table into a CalPrimaryBeamTableIDL CORBA structure.
398 : *
399 : * @return a pointer to a CalPrimaryBeamTableIDL
400 : */
401 : asdmIDL::CalPrimaryBeamTableIDL *toIDL() ;
402 :
403 : /**
404 : * Fills the CORBA data structure passed in parameter
405 : * with the content of this table.
406 : *
407 : * @param x a reference to the asdmIDL::CalPrimaryBeamTableIDL to be populated
408 : * with the content of this.
409 : */
410 : void toIDL(asdmIDL::CalPrimaryBeamTableIDL& x) const;
411 :
412 : #endif
413 :
414 : #ifndef WITHOUT_ACS
415 : /**
416 : * Populate this table from the content of a CalPrimaryBeamTableIDL Corba structure.
417 : *
418 : * @throws DuplicateKey Thrown if the method tries to add a row having a key that is already in the table.
419 : * @throws ConversionException
420 : */
421 : void fromIDL(asdmIDL::CalPrimaryBeamTableIDL x) ;
422 : #endif
423 :
424 : //
425 : // ====> Row creation.
426 : //
427 :
428 : /**
429 : * Create a new row with default values.
430 : * @return a pointer on a CalPrimaryBeamRow
431 : */
432 : CalPrimaryBeamRow *newRow();
433 :
434 :
435 : /**
436 : * Create a new row initialized to the specified values.
437 : * @return a pointer on the created and initialized row.
438 :
439 : * @param antennaName
440 :
441 : * @param receiverBand
442 :
443 : * @param calDataId
444 :
445 : * @param calReductionId
446 :
447 : * @param startValidTime
448 :
449 : * @param endValidTime
450 :
451 : * @param antennaMake
452 :
453 : * @param numSubband
454 :
455 : * @param frequencyRange
456 :
457 : * @param numReceptor
458 :
459 : * @param polarizationTypes
460 :
461 : * @param mainBeamEfficiency
462 :
463 : * @param beamDescriptionUID
464 :
465 : * @param relativeAmplitudeRms
466 :
467 : * @param direction
468 :
469 : * @param minValidDirection
470 :
471 : * @param maxValidDirection
472 :
473 : * @param descriptionType
474 :
475 : * @param imageChannelNumber
476 :
477 : * @param imageNominalFrequency
478 :
479 : */
480 : CalPrimaryBeamRow *newRow(std::string antennaName, ReceiverBandMod::ReceiverBand receiverBand, Tag calDataId, Tag calReductionId, ArrayTime startValidTime, ArrayTime endValidTime, AntennaMakeMod::AntennaMake antennaMake, int numSubband, std::vector<std::vector<Frequency > > frequencyRange, int numReceptor, std::vector<PolarizationTypeMod::PolarizationType > polarizationTypes, std::vector<double > mainBeamEfficiency, EntityRef beamDescriptionUID, float relativeAmplitudeRms, std::vector<Angle > direction, std::vector<Angle > minValidDirection, std::vector<Angle > maxValidDirection, PrimaryBeamDescriptionMod::PrimaryBeamDescription descriptionType, std::vector<int > imageChannelNumber, std::vector<Frequency > imageNominalFrequency);
481 :
482 :
483 :
484 : /**
485 : * Create a new row using a copy constructor mechanism.
486 : *
487 : * The method creates a new CalPrimaryBeamRow owned by this. Each attribute of the created row
488 : * is a (deep) copy of the corresponding attribute of row. The method does not add
489 : * the created row to this, its simply parents it to this, a call to the add method
490 : * has to be done in order to get the row added (very likely after having modified
491 : * some of its attributes).
492 : * If row is null then the method returns a new CalPrimaryBeamRow with default values for its attributes.
493 : *
494 : * @param row the row which is to be copied.
495 : */
496 : CalPrimaryBeamRow *newRow(CalPrimaryBeamRow *row);
497 :
498 : //
499 : // ====> Append a row to its table.
500 : //
501 :
502 :
503 : /**
504 : * Add a row.
505 : * @param x a pointer to the CalPrimaryBeamRow to be added.
506 : *
507 : * @return a pointer to a CalPrimaryBeamRow. If the table contains a CalPrimaryBeamRow whose attributes (key and mandatory values) are equal to x ones
508 : * then returns a pointer on that CalPrimaryBeamRow, otherwise returns x.
509 : *
510 : * @throw DuplicateKey { thrown when the table contains a CalPrimaryBeamRow with a key equal to the x one but having
511 : * and a value section different from x one }
512 : *
513 :
514 : */
515 : CalPrimaryBeamRow* add(CalPrimaryBeamRow* x) ;
516 :
517 :
518 :
519 :
520 :
521 : //
522 : // ====> Methods returning rows.
523 : //
524 :
525 : /**
526 : * Get a collection of pointers on the rows of the table.
527 : * @return Alls rows in a vector of pointers of CalPrimaryBeamRow. The elements of this vector are stored in the order
528 : * in which they have been added to the CalPrimaryBeamTable.
529 : */
530 : std::vector<CalPrimaryBeamRow *> get() ;
531 :
532 : /**
533 : * Get a const reference on the collection of rows pointers internally hold by the table.
534 : * @return A const reference of a vector of pointers of CalPrimaryBeamRow. The elements of this vector are stored in the order
535 : * in which they have been added to the CalPrimaryBeamTable.
536 : *
537 : */
538 : const std::vector<CalPrimaryBeamRow *>& get() const ;
539 :
540 :
541 :
542 :
543 :
544 : /**
545 : * Returns a CalPrimaryBeamRow* given a key.
546 : * @return a pointer to the row having the key whose values are passed as parameters, or 0 if
547 : * no row exists for that key.
548 :
549 : * @param antennaName
550 :
551 : * @param receiverBand
552 :
553 : * @param calDataId
554 :
555 : * @param calReductionId
556 :
557 : *
558 : */
559 : CalPrimaryBeamRow* getRowByKey(std::string antennaName, ReceiverBandMod::ReceiverBand receiverBand, Tag calDataId, Tag calReductionId);
560 :
561 :
562 :
563 :
564 :
565 : /**
566 : * Look up the table for a row whose all attributes
567 : * are equal to the corresponding parameters of the method.
568 : * @return a pointer on this row if any, null otherwise.
569 : *
570 :
571 : * @param antennaName
572 :
573 : * @param receiverBand
574 :
575 : * @param calDataId
576 :
577 : * @param calReductionId
578 :
579 : * @param startValidTime
580 :
581 : * @param endValidTime
582 :
583 : * @param antennaMake
584 :
585 : * @param numSubband
586 :
587 : * @param frequencyRange
588 :
589 : * @param numReceptor
590 :
591 : * @param polarizationTypes
592 :
593 : * @param mainBeamEfficiency
594 :
595 : * @param beamDescriptionUID
596 :
597 : * @param relativeAmplitudeRms
598 :
599 : * @param direction
600 :
601 : * @param minValidDirection
602 :
603 : * @param maxValidDirection
604 :
605 : * @param descriptionType
606 :
607 : * @param imageChannelNumber
608 :
609 : * @param imageNominalFrequency
610 :
611 : */
612 : CalPrimaryBeamRow* lookup(std::string antennaName, ReceiverBandMod::ReceiverBand receiverBand, Tag calDataId, Tag calReductionId, ArrayTime startValidTime, ArrayTime endValidTime, AntennaMakeMod::AntennaMake antennaMake, int numSubband, std::vector<std::vector<Frequency > > frequencyRange, int numReceptor, std::vector<PolarizationTypeMod::PolarizationType > polarizationTypes, std::vector<double > mainBeamEfficiency, EntityRef beamDescriptionUID, float relativeAmplitudeRms, std::vector<Angle > direction, std::vector<Angle > minValidDirection, std::vector<Angle > maxValidDirection, PrimaryBeamDescriptionMod::PrimaryBeamDescription descriptionType, std::vector<int > imageChannelNumber, std::vector<Frequency > imageNominalFrequency);
613 :
614 :
615 : void setUnknownAttributeBinaryReader(const std::string& attributeName, BinaryAttributeReaderFunctor* barFctr);
616 : BinaryAttributeReaderFunctor* getUnknownAttributeBinaryReader(const std::string& attributeName) const;
617 :
618 : private:
619 :
620 : /**
621 : * Create a CalPrimaryBeamTable.
622 : * <p>
623 : * This constructor is private because only the
624 : * container can create tables. All tables must know the container
625 : * to which they belong.
626 : * @param container The container to which this table belongs.
627 : */
628 : CalPrimaryBeamTable (ASDM & container);
629 :
630 : ASDM & container;
631 :
632 : bool archiveAsBin; // If true archive binary else archive XML
633 : bool fileAsBin ; // If true file binary else file XML
634 :
635 : std::string version ;
636 :
637 : Entity entity;
638 :
639 :
640 :
641 :
642 :
643 :
644 : /**
645 : * If this table has an autoincrementable attribute then check if *x verifies the rule of uniqueness and throw exception if not.
646 : * Check if *x verifies the key uniqueness rule and throw an exception if not.
647 : * Append x to its table.
648 : * @throws DuplicateKey
649 :
650 : */
651 : CalPrimaryBeamRow* checkAndAdd(CalPrimaryBeamRow* x, bool skipCheckUniqueness=false) ;
652 :
653 : /**
654 : * Brutally append an CalPrimaryBeamRow x to the collection of rows already stored in this table. No uniqueness check is done !
655 : *
656 : * @param CalPrimaryBeamRow* x a pointer onto the CalPrimaryBeamRow to be appended.
657 : */
658 : void append(CalPrimaryBeamRow* x) ;
659 :
660 : /**
661 : * Brutally append an CalPrimaryBeamRow x to the collection of rows already stored in this table. No uniqueness check is done !
662 : *
663 : * @param CalPrimaryBeamRow* x a pointer onto the CalPrimaryBeamRow to be appended.
664 : */
665 : void addWithoutCheckingUnique(CalPrimaryBeamRow* x) ;
666 :
667 :
668 :
669 :
670 :
671 : // A data structure to store the pointers on the table's rows.
672 :
673 : // In all cases we maintain a private vector of CalPrimaryBeamRow s.
674 : std::vector<CalPrimaryBeamRow * > privateRows;
675 :
676 :
677 :
678 : std::vector<CalPrimaryBeamRow *> row;
679 :
680 :
681 : void error() ; //throw(ConversionException);
682 :
683 :
684 : /**
685 : * Populate this table from the content of a XML document that is required to
686 : * be conform to the XML schema defined for a CalPrimaryBeam (CalPrimaryBeamTable.xsd).
687 : * @throws ConversionException
688 : *
689 : */
690 : void fromXML(std::string& xmlDoc) ;
691 :
692 : std::map<std::string, BinaryAttributeReaderFunctor *> unknownAttributes2Functors;
693 :
694 : /**
695 : * Private methods involved during the build of this table out of the content
696 : * of file(s) containing an external representation of a CalPrimaryBeam table.
697 : */
698 : void setFromMIMEFile(const std::string& directory);
699 : /*
700 : void openMIMEFile(const std::string& directory);
701 : */
702 : void setFromXMLFile(const std::string& directory);
703 :
704 : /**
705 : * Serialize this into a stream of bytes and encapsulates that stream into a MIME message.
706 : * @returns a string containing the MIME message.
707 : *
708 : * @param byteOrder a const pointer to a static instance of the class ByteOrder.
709 : *
710 : */
711 : std::string toMIME(const asdm::ByteOrder* byteOrder=asdm::ByteOrder::Machine_Endianity);
712 :
713 :
714 : /**
715 : * Extracts the binary part of a MIME message and deserialize its content
716 : * to fill this with the result of the deserialization.
717 : * @param mimeMsg the string containing the MIME message.
718 : * @throws ConversionException
719 : */
720 : void setFromMIME(const std::string & mimeMsg);
721 :
722 : /**
723 : * Private methods involved during the export of this table into disk file(s).
724 : */
725 : std::string MIMEXMLPart(const asdm::ByteOrder* byteOrder=asdm::ByteOrder::Machine_Endianity);
726 :
727 : /**
728 : * Stores a representation (binary or XML) of this table into a file.
729 : *
730 : * Depending on the boolean value of its private field fileAsBin a binary serialization of this (fileAsBin==true)
731 : * will be saved in a file "CalPrimaryBeam.bin" or an XML representation (fileAsBin==false) will be saved in a file "CalPrimaryBeam.xml".
732 : * The file is always written in a directory whose name is passed as a parameter.
733 : * @param directory The name of directory where the file containing the table's representation will be saved.
734 : *
735 : */
736 : void toFile(std::string directory);
737 :
738 : /**
739 : * Load the table in memory if necessary.
740 : */
741 : bool loadInProgress;
742 0 : void checkPresenceInMemory() {
743 0 : if (!presentInMemory && !loadInProgress) {
744 0 : loadInProgress = true;
745 0 : setFromFile(getContainer().getDirectory());
746 0 : presentInMemory = true;
747 0 : loadInProgress = false;
748 : }
749 0 : }
750 : /**
751 : * Reads and parses a file containing a representation of a CalPrimaryBeamTable as those produced by the toFile method.
752 : * This table is populated with the result of the parsing.
753 : * @param directory The name of the directory containing the file te be read and parsed.
754 : * @throws ConversionException If any error occurs while reading the
755 : * files in the directory or parsing them.
756 : *
757 : */
758 : void setFromFile(const std::string& directory);
759 :
760 : };
761 :
762 : } // End namespace asdm
763 :
764 : #endif /* CalPrimaryBeamTable_CLASS */
|
