casa  $Rev:20696$
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
CalSeeingRow.h
Go to the documentation of this file.
00001 
00002 /*
00003  * ALMA - Atacama Large Millimeter Array
00004  * (c) European Southern Observatory, 2002
00005  * (c) Associated Universities Inc., 2002
00006  * Copyright by ESO (in the framework of the ALMA collaboration),
00007  * Copyright by AUI (in the framework of the ALMA collaboration),
00008  * All rights reserved.
00009  * 
00010  * This library is free software; you can redistribute it and/or
00011  * modify it under the terms of the GNU Lesser General Public
00012  * License as published by the Free software Foundation; either
00013  * version 2.1 of the License, or (at your option) any later version.
00014  * 
00015  * This library is distributed in the hope that it will be useful,
00016  * but WITHOUT ANY WARRANTY, without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00018  * Lesser General Public License for more details.
00019  * 
00020  * You should have received a copy of the GNU Lesser General Public
00021  * License along with this library; if not, write to the Free Software
00022  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
00023  * MA 02111-1307  USA
00024  *
00025  * Warning!
00026  *  -------------------------------------------------------------------- 
00027  * | This is generated code!  Do not modify this file.                  |
00028  * | If you do, all changes will be lost when the file is re-generated. |
00029  *  --------------------------------------------------------------------
00030  *
00031  * File CalSeeingRow.h
00032  */
00033  
00034 #ifndef CalSeeingRow_CLASS
00035 #define CalSeeingRow_CLASS
00036 
00037 #include <vector>
00038 #include <string>
00039 #include <set>
00040 
00041 #ifndef WITHOUT_ACS
00042 #include <asdmIDLC.h>
00043 #endif
00044 
00045 
00046 
00047 
00048 
00049 
00050          
00051 #include <ArrayTime.h>
00052         
00053 
00054          
00055 #include <Angle.h>
00056         
00057 
00058          
00059 #include <Interval.h>
00060         
00061 
00062          
00063 #include <Tag.h>
00064         
00065 
00066          
00067 #include <Length.h>
00068         
00069 
00070          
00071 #include <Frequency.h>
00072         
00073 
00074 
00075 
00076 
00077         
00078 #include "CAtmPhaseCorrection.h"
00079         
00080 
00081         
00082 
00083         
00084 
00085         
00086 
00087         
00088 
00089         
00090 
00091         
00092 
00093         
00094 
00095         
00096 
00097         
00098 
00099         
00100 
00101         
00102 
00103         
00104 
00105 
00106 
00107 #include <ConversionException.h>
00108 #include <NoSuchRow.h>
00109 #include <IllegalAccessException.h>
00110 
00111 #include <RowTransformer.h>
00112 //#include <TableStreamReader.h>
00113 
00114 /*\file CalSeeing.h
00115     \brief Generated from model's revision "1.64", branch "HEAD"
00116 */
00117 
00118 namespace asdm {
00119 
00120 //class asdm::CalSeeingTable;
00121 
00122 
00123 // class asdm::CalDataRow;
00124 class CalDataRow;
00125 
00126 // class asdm::CalReductionRow;
00127 class CalReductionRow;
00128         
00129 
00130 class CalSeeingRow;
00131 typedef void (CalSeeingRow::*CalSeeingAttributeFromBin) (EndianIStream& eis);
00132 typedef void (CalSeeingRow::*CalSeeingAttributeFromText) (const string& s);
00133 
00140 class CalSeeingRow {
00141 friend class asdm::CalSeeingTable;
00142 friend class asdm::RowTransformer<CalSeeingRow>;
00143 //friend class asdm::TableStreamReader<CalSeeingTable, CalSeeingRow>;
00144 
00145 public:
00146 
00147         virtual ~CalSeeingRow();
00148 
00152         CalSeeingTable &getTable() const;
00153         
00158         bool isAdded() const;
00159                 
00161         // Intrinsic Table Attributes //
00163         
00164         
00165         // ===> Attribute atmPhaseCorrection
00166         
00167         
00168         
00169 
00170         
00175         AtmPhaseCorrectionMod::AtmPhaseCorrection getAtmPhaseCorrection() const;
00176         
00177  
00178         
00179         
00189         void setAtmPhaseCorrection (AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection);
00190                 
00191         
00192         
00193         
00194 
00195 
00196         
00197         // ===> Attribute startValidTime
00198         
00199         
00200         
00201 
00202         
00207         ArrayTime getStartValidTime() const;
00208         
00209  
00210         
00211         
00219         void setStartValidTime (ArrayTime startValidTime);
00220                 
00221         
00222         
00223         
00224 
00225 
00226         
00227         // ===> Attribute endValidTime
00228         
00229         
00230         
00231 
00232         
00237         ArrayTime getEndValidTime() const;
00238         
00239  
00240         
00241         
00249         void setEndValidTime (ArrayTime endValidTime);
00250                 
00251         
00252         
00253         
00254 
00255 
00256         
00257         // ===> Attribute frequencyRange
00258         
00259         
00260         
00261 
00262         
00267         vector<Frequency > getFrequencyRange() const;
00268         
00269  
00270         
00271         
00279         void setFrequencyRange (vector<Frequency > frequencyRange);
00280                 
00281         
00282         
00283         
00284 
00285 
00286         
00287         // ===> Attribute integrationTime
00288         
00289         
00290         
00291 
00292         
00297         Interval getIntegrationTime() const;
00298         
00299  
00300         
00301         
00309         void setIntegrationTime (Interval integrationTime);
00310                 
00311         
00312         
00313         
00314 
00315 
00316         
00317         // ===> Attribute numBaseLengths
00318         
00319         
00320         
00321 
00322         
00327         int getNumBaseLengths() const;
00328         
00329  
00330         
00331         
00339         void setNumBaseLengths (int numBaseLengths);
00340                 
00341         
00342         
00343         
00344 
00345 
00346         
00347         // ===> Attribute baselineLengths
00348         
00349         
00350         
00351 
00352         
00357         vector<Length > getBaselineLengths() const;
00358         
00359  
00360         
00361         
00369         void setBaselineLengths (vector<Length > baselineLengths);
00370                 
00371         
00372         
00373         
00374 
00375 
00376         
00377         // ===> Attribute phaseRMS
00378         
00379         
00380         
00381 
00382         
00387         vector<Angle > getPhaseRMS() const;
00388         
00389  
00390         
00391         
00399         void setPhaseRMS (vector<Angle > phaseRMS);
00400                 
00401         
00402         
00403         
00404 
00405 
00406         
00407         // ===> Attribute seeing
00408         
00409         
00410         
00411 
00412         
00417         Angle getSeeing() const;
00418         
00419  
00420         
00421         
00429         void setSeeing (Angle seeing);
00430                 
00431         
00432         
00433         
00434 
00435 
00436         
00437         // ===> Attribute seeingError
00438         
00439         
00440         
00441 
00442         
00447         Angle getSeeingError() const;
00448         
00449  
00450         
00451         
00459         void setSeeingError (Angle seeingError);
00460                 
00461         
00462         
00463         
00464 
00465 
00466         
00467         // ===> Attribute exponent, which is optional
00468         
00469         
00470         
00475         bool isExponentExists() const;
00476         
00477 
00478         
00484         float getExponent() const;
00485         
00486  
00487         
00488         
00495         void setExponent (float exponent);
00496                 
00497         
00498         
00499         
00503         void clearExponent ();
00504         
00505 
00506 
00507         
00508         // ===> Attribute outerScale, which is optional
00509         
00510         
00511         
00516         bool isOuterScaleExists() const;
00517         
00518 
00519         
00525         Length getOuterScale() const;
00526         
00527  
00528         
00529         
00536         void setOuterScale (Length outerScale);
00537                 
00538         
00539         
00540         
00544         void clearOuterScale ();
00545         
00546 
00547 
00548         
00549         // ===> Attribute outerScaleRMS, which is optional
00550         
00551         
00552         
00557         bool isOuterScaleRMSExists() const;
00558         
00559 
00560         
00566         Angle getOuterScaleRMS() const;
00567         
00568  
00569         
00570         
00577         void setOuterScaleRMS (Angle outerScaleRMS);
00578                 
00579         
00580         
00581         
00585         void clearOuterScaleRMS ();
00586         
00587 
00588 
00590         // Extrinsic Table Attributes //
00592         
00593         
00594         // ===> Attribute calDataId
00595         
00596         
00597         
00598 
00599         
00604         Tag getCalDataId() const;
00605         
00606  
00607         
00608         
00618         void setCalDataId (Tag calDataId);
00619                 
00620         
00621         
00622         
00623 
00624 
00625         
00626         // ===> Attribute calReductionId
00627         
00628         
00629         
00630 
00631         
00636         Tag getCalReductionId() const;
00637         
00638  
00639         
00640         
00650         void setCalReductionId (Tag calReductionId);
00651                 
00652         
00653         
00654         
00655 
00656 
00658         // Links //
00660         
00661         
00662 
00663         
00664                 
00671          CalDataRow* getCalDataUsingCalDataId();
00672          
00673 
00674         
00675 
00676         
00677 
00678         
00679                 
00686          CalReductionRow* getCalReductionUsingCalReductionId();
00687          
00688 
00689         
00690 
00691         
00692         
00693         
00723         bool compareNoAutoInc(AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection, Tag calDataId, Tag calReductionId, ArrayTime startValidTime, ArrayTime endValidTime, vector<Frequency > frequencyRange, Interval integrationTime, int numBaseLengths, vector<Length > baselineLengths, vector<Angle > phaseRMS, Angle seeing, Angle seeingError);
00724         
00725         
00726 
00727         
00751         bool compareRequiredValue(ArrayTime startValidTime, ArrayTime endValidTime, vector<Frequency > frequencyRange, Interval integrationTime, int numBaseLengths, vector<Length > baselineLengths, vector<Angle > phaseRMS, Angle seeing, Angle seeingError); 
00752                  
00753         
00762         bool equalByRequiredValue(CalSeeingRow* x) ;
00763         
00764 #ifndef WITHOUT_ACS
00765 
00769         asdmIDL::CalSeeingRowIDL *toIDL() const;
00770         
00778          void toIDL(asdmIDL::CalSeeingRowIDL& x) const;
00779 #endif
00780         
00781 #ifndef WITHOUT_ACS
00782 
00787         void setFromIDL (asdmIDL::CalSeeingRowIDL x) ;
00788 #endif
00789         
00794         std::string toXML() const;
00795 
00802         void setFromXML (std::string rowDoc) ;
00803 
00806         // binary-deserialization material from an EndianIStream  //
00808 
00809         std::map<std::string, CalSeeingAttributeFromBin> fromBinMethods;
00810 void atmPhaseCorrectionFromBin( EndianIStream& eis);
00811 void calDataIdFromBin( EndianIStream& eis);
00812 void calReductionIdFromBin( EndianIStream& eis);
00813 void startValidTimeFromBin( EndianIStream& eis);
00814 void endValidTimeFromBin( EndianIStream& eis);
00815 void frequencyRangeFromBin( EndianIStream& eis);
00816 void integrationTimeFromBin( EndianIStream& eis);
00817 void numBaseLengthsFromBin( EndianIStream& eis);
00818 void baselineLengthsFromBin( EndianIStream& eis);
00819 void phaseRMSFromBin( EndianIStream& eis);
00820 void seeingFromBin( EndianIStream& eis);
00821 void seeingErrorFromBin( EndianIStream& eis);
00822 
00823 void exponentFromBin( EndianIStream& eis);
00824 void outerScaleFromBin( EndianIStream& eis);
00825 void outerScaleRMSFromBin( EndianIStream& eis);
00826 
00827 
00835          static CalSeeingRow* fromBin(EndianIStream& eis, CalSeeingTable& table, const std::vector<std::string>& attributesSeq);         
00836  
00843          void fromText(const std::string& attributeName, const std::string&  t);
00845 
00846 private:
00850         CalSeeingTable &table;
00854         bool hasBeenAdded;
00855 
00856         // This method is used by the Table class when this row is added to the table.
00857         void isAdded(bool added);
00858 
00859 
00868         CalSeeingRow (CalSeeingTable &table);
00869 
00887          CalSeeingRow (CalSeeingTable &table, CalSeeingRow &row);
00888                 
00890         // Intrinsic Table Attributes //
00892         
00893         
00894         // ===> Attribute atmPhaseCorrection
00895         
00896         
00897 
00898         AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection;
00899 
00900         
00901         
00902         
00903 
00904         
00905         // ===> Attribute startValidTime
00906         
00907         
00908 
00909         ArrayTime startValidTime;
00910 
00911         
00912         
00913         
00914 
00915         
00916         // ===> Attribute endValidTime
00917         
00918         
00919 
00920         ArrayTime endValidTime;
00921 
00922         
00923         
00924         
00925 
00926         
00927         // ===> Attribute frequencyRange
00928         
00929         
00930 
00931         vector<Frequency > frequencyRange;
00932 
00933         
00934         
00935         
00936 
00937         
00938         // ===> Attribute integrationTime
00939         
00940         
00941 
00942         Interval integrationTime;
00943 
00944         
00945         
00946         
00947 
00948         
00949         // ===> Attribute numBaseLengths
00950         
00951         
00952 
00953         int numBaseLengths;
00954 
00955         
00956         
00957         
00958 
00959         
00960         // ===> Attribute baselineLengths
00961         
00962         
00963 
00964         vector<Length > baselineLengths;
00965 
00966         
00967         
00968         
00969 
00970         
00971         // ===> Attribute phaseRMS
00972         
00973         
00974 
00975         vector<Angle > phaseRMS;
00976 
00977         
00978         
00979         
00980 
00981         
00982         // ===> Attribute seeing
00983         
00984         
00985 
00986         Angle seeing;
00987 
00988         
00989         
00990         
00991 
00992         
00993         // ===> Attribute seeingError
00994         
00995         
00996 
00997         Angle seeingError;
00998 
00999         
01000         
01001         
01002 
01003         
01004         // ===> Attribute exponent, which is optional
01005         
01006         
01007         bool exponentExists;
01008         
01009 
01010         float exponent;
01011 
01012         
01013         
01014         
01015 
01016         
01017         // ===> Attribute outerScale, which is optional
01018         
01019         
01020         bool outerScaleExists;
01021         
01022 
01023         Length outerScale;
01024 
01025         
01026         
01027         
01028 
01029         
01030         // ===> Attribute outerScaleRMS, which is optional
01031         
01032         
01033         bool outerScaleRMSExists;
01034         
01035 
01036         Angle outerScaleRMS;
01037 
01038         
01039         
01040         
01041 
01043         // Extrinsic Table Attributes //
01045         
01046         
01047         // ===> Attribute calDataId
01048         
01049         
01050 
01051         Tag calDataId;
01052 
01053         
01054         
01055         
01056 
01057         
01058         // ===> Attribute calReductionId
01059         
01060         
01061 
01062         Tag calReductionId;
01063 
01064         
01065         
01066         
01067 
01069         // Links //
01071         
01072         
01073                 
01074 
01075          
01076 
01077         
01078 
01079         
01080                 
01081 
01082          
01083 
01084         
01085 
01086         
01087 /*
01089         // binary-deserialization material from an EndianIStream  //
01091         std::map<std::string, CalSeeingAttributeFromBin> fromBinMethods;
01092 void atmPhaseCorrectionFromBin( EndianIStream& eis);
01093 void calDataIdFromBin( EndianIStream& eis);
01094 void calReductionIdFromBin( EndianIStream& eis);
01095 void startValidTimeFromBin( EndianIStream& eis);
01096 void endValidTimeFromBin( EndianIStream& eis);
01097 void frequencyRangeFromBin( EndianIStream& eis);
01098 void integrationTimeFromBin( EndianIStream& eis);
01099 void numBaseLengthsFromBin( EndianIStream& eis);
01100 void baselineLengthsFromBin( EndianIStream& eis);
01101 void phaseRMSFromBin( EndianIStream& eis);
01102 void seeingFromBin( EndianIStream& eis);
01103 void seeingErrorFromBin( EndianIStream& eis);
01104 
01105 void exponentFromBin( EndianIStream& eis);
01106 void outerScaleFromBin( EndianIStream& eis);
01107 void outerScaleRMSFromBin( EndianIStream& eis);
01108 
01109 */
01110         
01112         // text-deserialization material //
01114         std::map<std::string, CalSeeingAttributeFromText> fromTextMethods;
01115         
01116 void atmPhaseCorrectionFromText (const string & s);
01117         
01118         
01119 void calDataIdFromText (const string & s);
01120         
01121         
01122 void calReductionIdFromText (const string & s);
01123         
01124         
01125 void startValidTimeFromText (const string & s);
01126         
01127         
01128 void endValidTimeFromText (const string & s);
01129         
01130         
01131 void frequencyRangeFromText (const string & s);
01132         
01133         
01134 void integrationTimeFromText (const string & s);
01135         
01136         
01137 void numBaseLengthsFromText (const string & s);
01138         
01139         
01140 void baselineLengthsFromText (const string & s);
01141         
01142         
01143 void phaseRMSFromText (const string & s);
01144         
01145         
01146 void seeingFromText (const string & s);
01147         
01148         
01149 void seeingErrorFromText (const string & s);
01150         
01151 
01152         
01153 void exponentFromText (const string & s);
01154         
01155         
01156 void outerScaleFromText (const string & s);
01157         
01158         
01159 void outerScaleRMSFromText (const string & s);
01160         
01161         
01162         
01167          void toBin(EndianOSStream& eoss);
01168                  
01178 };
01179 
01180 } // End namespace asdm
01181 
01182 #endif /* CalSeeing_CLASS */