LCOV - code coverage report
Current view: top level - alma/ASDM - ScanTable.h (source / functions) Hit Total Coverage
Test: casacpp_coverage.info Lines: 0 7 0.0 %
Date: 2024-10-04 18:58:15 Functions: 0 1 0.0 %

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

Generated by: LCOV version 1.16