AnnotationRow.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 AnnotationRow.h
00032  */
00033  
00034 #ifndef AnnotationRow_CLASS
00035 #define AnnotationRow_CLASS
00036 
00037 #include <vector>
00038 #include <string>
00039 #include <set>
00040 using std::vector;
00041 using std::string;
00042 using std::set;
00043 
00044 #ifndef WITHOUT_ACS
00045 #include <asdmIDLC.h>
00046 using asdmIDL::AnnotationRowIDL;
00047 #endif
00048 
00049 #include <Angle.h>
00050 #include <AngularRate.h>
00051 #include <ArrayTime.h>
00052 #include <ArrayTimeInterval.h>
00053 #include <Complex.h>
00054 #include <Entity.h>
00055 #include <EntityId.h>
00056 #include <EntityRef.h>
00057 #include <Flux.h>
00058 #include <Frequency.h>
00059 #include <Humidity.h>
00060 #include <Interval.h>
00061 #include <Length.h>
00062 #include <Pressure.h>
00063 #include <Speed.h>
00064 #include <Tag.h>
00065 #include <Temperature.h>
00066 #include <ConversionException.h>
00067 #include <NoSuchRow.h>
00068 #include <IllegalAccessException.h>
00069 
00070 /*
00071 #include <Enumerations.h>
00072 using namespace enumerations;
00073  */
00074 
00075 
00076 
00077 
00078         
00079 
00080         
00081 
00082         
00083 
00084         
00085 
00086         
00087 
00088         
00089 
00090         
00091 #include "CBasebandName.h"
00092 using namespace BasebandNameMod;
00093         
00094 
00095         
00096 
00097         
00098 
00099         
00100 
00101         
00102 
00103         
00104 
00105         
00106 
00107         
00108 
00109 
00110 
00111 using asdm::Angle;
00112 using asdm::AngularRate;
00113 using asdm::ArrayTime;
00114 using asdm::Complex;
00115 using asdm::Entity;
00116 using asdm::EntityId;
00117 using asdm::EntityRef;
00118 using asdm::Flux;
00119 using asdm::Frequency;
00120 using asdm::Humidity;
00121 using asdm::Interval;
00122 using asdm::Length;
00123 using asdm::Pressure;
00124 using asdm::Speed;
00125 using asdm::Tag;
00126 using asdm::Temperature;
00127 using asdm::ConversionException;
00128 using asdm::NoSuchRow;
00129 using asdm::IllegalAccessException;
00130 
00131 /*\file Annotation.h
00132     \brief Generated from model's revision "1.46", branch "ALMA-5_1_1-B"
00133 */
00134 
00135 namespace asdm {
00136 
00137 //class asdm::AnnotationTable;
00138 
00139 
00140 // class asdm::AntennaRow;
00141 class AntennaRow;
00142         
00143 
00150 class AnnotationRow {
00151 friend class asdm::AnnotationTable;
00152 
00153 public:
00154 
00155         virtual ~AnnotationRow();
00156 
00160         AnnotationTable &getTable() const;
00161         
00162 #ifndef WITHOUT_ACS
00163 
00167         AnnotationRowIDL *toIDL() const;
00168 #endif
00169         
00170 #ifndef WITHOUT_ACS
00171 
00175         void setFromIDL (AnnotationRowIDL x) throw(ConversionException);
00176 #endif
00177         
00182         string toXML() const;
00183 
00189         void setFromXML (string rowDoc) throw(ConversionException);
00190         
00192         // Intrinsic Table Attributes //
00194         
00195         
00196         // ===> Attribute time
00197         
00198         
00199         
00200 
00201         
00206         ArrayTime getTime() const;
00207         
00208  
00209         
00210         
00218         void setTime (ArrayTime time) throw(IllegalAccessException);
00219                 
00220         
00221         
00222         
00223 
00224 
00225         
00226         // ===> Attribute issue
00227         
00228         
00229         
00230 
00231         
00236         string getIssue() const;
00237         
00238  
00239         
00240         
00248         void setIssue (string issue) throw(IllegalAccessException);
00249                 
00250         
00251         
00252         
00253 
00254 
00255         
00256         // ===> Attribute details
00257         
00258         
00259         
00260 
00261         
00266         string getDetails() const;
00267         
00268  
00269         
00270         
00278         void setDetails (string details) throw(IllegalAccessException);
00279                 
00280         
00281         
00282         
00283 
00284 
00285         
00286         // ===> Attribute interval, which is optional
00287         
00288         
00289         
00294         bool isIntervalExists() const;
00295         
00296 
00297         
00303         Interval getInterval() const throw(IllegalAccessException);
00304         
00305  
00306         
00307         
00314         void setInterval (Interval interval);
00315                 
00316         
00317         
00318         
00322         void clearInterval ();
00323         
00324 
00325 
00326         
00327         // ===> Attribute numAntenna, which is optional
00328         
00329         
00330         
00335         bool isNumAntennaExists() const;
00336         
00337 
00338         
00344         int getNumAntenna() const throw(IllegalAccessException);
00345         
00346  
00347         
00348         
00355         void setNumAntenna (int numAntenna);
00356                 
00357         
00358         
00359         
00363         void clearNumAntenna ();
00364         
00365 
00366 
00367         
00368         // ===> Attribute numBaseband, which is optional
00369         
00370         
00371         
00376         bool isNumBasebandExists() const;
00377         
00378 
00379         
00385         int getNumBaseband() const throw(IllegalAccessException);
00386         
00387  
00388         
00389         
00396         void setNumBaseband (int numBaseband);
00397                 
00398         
00399         
00400         
00404         void clearNumBaseband ();
00405         
00406 
00407 
00408         
00409         // ===> Attribute basebandName, which is optional
00410         
00411         
00412         
00417         bool isBasebandNameExists() const;
00418         
00419 
00420         
00426         vector<BasebandNameMod::BasebandName > getBasebandName() const throw(IllegalAccessException);
00427         
00428  
00429         
00430         
00437         void setBasebandName (vector<BasebandNameMod::BasebandName > basebandName);
00438                 
00439         
00440         
00441         
00445         void clearBasebandName ();
00446         
00447 
00448 
00449         
00450         // ===> Attribute dValue, which is optional
00451         
00452         
00453         
00458         bool isDValueExists() const;
00459         
00460 
00461         
00467         double getDValue() const throw(IllegalAccessException);
00468         
00469  
00470         
00471         
00478         void setDValue (double dValue);
00479                 
00480         
00481         
00482         
00486         void clearDValue ();
00487         
00488 
00489 
00490         
00491         // ===> Attribute vdValue, which is optional
00492         
00493         
00494         
00499         bool isVdValueExists() const;
00500         
00501 
00502         
00508         vector<double > getVdValue() const throw(IllegalAccessException);
00509         
00510  
00511         
00512         
00519         void setVdValue (vector<double > vdValue);
00520                 
00521         
00522         
00523         
00527         void clearVdValue ();
00528         
00529 
00530 
00531         
00532         // ===> Attribute vvdValues, which is optional
00533         
00534         
00535         
00540         bool isVvdValuesExists() const;
00541         
00542 
00543         
00549         vector<vector<double > > getVvdValues() const throw(IllegalAccessException);
00550         
00551  
00552         
00553         
00560         void setVvdValues (vector<vector<double > > vvdValues);
00561                 
00562         
00563         
00564         
00568         void clearVvdValues ();
00569         
00570 
00571 
00572         
00573         // ===> Attribute llValue, which is optional
00574         
00575         
00576         
00581         bool isLlValueExists() const;
00582         
00583 
00584         
00590         long long getLlValue() const throw(IllegalAccessException);
00591         
00592  
00593         
00594         
00601         void setLlValue (long long llValue);
00602                 
00603         
00604         
00605         
00609         void clearLlValue ();
00610         
00611 
00612 
00613         
00614         // ===> Attribute vllValue, which is optional
00615         
00616         
00617         
00622         bool isVllValueExists() const;
00623         
00624 
00625         
00631         vector<long long > getVllValue() const throw(IllegalAccessException);
00632         
00633  
00634         
00635         
00642         void setVllValue (vector<long long > vllValue);
00643                 
00644         
00645         
00646         
00650         void clearVllValue ();
00651         
00652 
00653 
00654         
00655         // ===> Attribute vvllValue, which is optional
00656         
00657         
00658         
00663         bool isVvllValueExists() const;
00664         
00665 
00666         
00672         vector<vector<long long > > getVvllValue() const throw(IllegalAccessException);
00673         
00674  
00675         
00676         
00683         void setVvllValue (vector<vector<long long > > vvllValue);
00684                 
00685         
00686         
00687         
00691         void clearVvllValue ();
00692         
00693 
00694 
00695         
00696         // ===> Attribute annotationId
00697         
00698         
00699         
00700 
00701         
00706         Tag getAnnotationId() const;
00707         
00708  
00709         
00710         
00711         
00712         
00713 
00714 
00716         // Extrinsic Table Attributes //
00718         
00719         
00720         // ===> Attribute antennaId, which is optional
00721         
00722         
00723         
00728         bool isAntennaIdExists() const;
00729         
00730 
00731         
00737         vector<Tag>  getAntennaId() const throw(IllegalAccessException);
00738         
00739  
00740         
00741         
00748         void setAntennaId (vector<Tag>  antennaId);
00749                 
00750         
00751         
00752         
00756         void clearAntennaId ();
00757         
00758 
00759 
00761         // Links //
00763         
00764         
00765                 
00773         void setAntennaId (int i, Tag antennaId) throw(IllegalAccessException, OutOfBoundsException); 
00774                         
00775         
00776 
00777         
00778                  
00783  void addAntennaId(Tag id); 
00784 
00789  void addAntennaId(const vector<Tag> & id); 
00790  
00791 
00797  const Tag getAntennaId(int i);
00798  
00806  AntennaRow* getAntenna(int i); 
00807  
00812  vector<AntennaRow *> getAntennas(); 
00813   
00814 
00815         
00816 
00817         
00818         
00819         
00824         bool compareNoAutoInc(ArrayTime time, string issue, string details);
00825         
00826         
00827 
00828         
00829         bool compareRequiredValue(ArrayTime time, string issue, string details); 
00830                  
00831         
00840         bool equalByRequiredValue(AnnotationRow* x) ;
00841 
00842 private:
00846         AnnotationTable &table;
00850         bool hasBeenAdded;
00851 
00852         // This method is used by the Table class when this row is added to the table.
00853         void isAdded();
00854 
00855 
00864         AnnotationRow (AnnotationTable &table);
00865 
00883          AnnotationRow (AnnotationTable &table, AnnotationRow &row);
00884                 
00886         // Intrinsic Table Attributes //
00888         
00889         
00890         // ===> Attribute time
00891         
00892         
00893 
00894         ArrayTime time;
00895 
00896         
00897         
00898         
00899 
00900         
00901         // ===> Attribute issue
00902         
00903         
00904 
00905         string issue;
00906 
00907         
00908         
00909         
00910 
00911         
00912         // ===> Attribute details
00913         
00914         
00915 
00916         string details;
00917 
00918         
00919         
00920         
00921 
00922         
00923         // ===> Attribute interval, which is optional
00924         
00925         
00926         bool intervalExists;
00927         
00928 
00929         Interval interval;
00930 
00931         
00932         
00933         
00934 
00935         
00936         // ===> Attribute numAntenna, which is optional
00937         
00938         
00939         bool numAntennaExists;
00940         
00941 
00942         int numAntenna;
00943 
00944         
00945         
00946         
00947 
00948         
00949         // ===> Attribute numBaseband, which is optional
00950         
00951         
00952         bool numBasebandExists;
00953         
00954 
00955         int numBaseband;
00956 
00957         
00958         
00959         
00960 
00961         
00962         // ===> Attribute basebandName, which is optional
00963         
00964         
00965         bool basebandNameExists;
00966         
00967 
00968         vector<BasebandNameMod::BasebandName > basebandName;
00969 
00970         
00971         
00972         
00973 
00974         
00975         // ===> Attribute dValue, which is optional
00976         
00977         
00978         bool dValueExists;
00979         
00980 
00981         double dValue;
00982 
00983         
00984         
00985         
00986 
00987         
00988         // ===> Attribute vdValue, which is optional
00989         
00990         
00991         bool vdValueExists;
00992         
00993 
00994         vector<double > vdValue;
00995 
00996         
00997         
00998         
00999 
01000         
01001         // ===> Attribute vvdValues, which is optional
01002         
01003         
01004         bool vvdValuesExists;
01005         
01006 
01007         vector<vector<double > > vvdValues;
01008 
01009         
01010         
01011         
01012 
01013         
01014         // ===> Attribute llValue, which is optional
01015         
01016         
01017         bool llValueExists;
01018         
01019 
01020         long long llValue;
01021 
01022         
01023         
01024         
01025 
01026         
01027         // ===> Attribute vllValue, which is optional
01028         
01029         
01030         bool vllValueExists;
01031         
01032 
01033         vector<long long > vllValue;
01034 
01035         
01036         
01037         
01038 
01039         
01040         // ===> Attribute vvllValue, which is optional
01041         
01042         
01043         bool vvllValueExists;
01044         
01045 
01046         vector<vector<long long > > vvllValue;
01047 
01048         
01049         
01050         
01051 
01052         
01053         // ===> Attribute annotationId
01054         
01055         
01056 
01057         Tag annotationId;
01058 
01059         
01060         
01061         
01069         void setAnnotationId (Tag annotationId) throw(IllegalAccessException);
01070                 
01071         
01072 
01074         // Extrinsic Table Attributes //
01076         
01077         
01078         // ===> Attribute antennaId, which is optional
01079         
01080         
01081         bool antennaIdExists;
01082         
01083 
01084         vector<Tag>  antennaId;
01085 
01086         
01087         
01088         
01089 
01091         // Links //
01093         
01094         
01095                 
01096 
01097 
01098         
01099 
01100 
01101 };
01102 
01103 } // End namespace asdm
01104 
01105 #endif /* Annotation_CLASS */

Generated on Tue Aug 26 22:21:00 2008 for NRAOCASA by  doxygen 1.5.1