ASDM.h

Go to the documentation of this file.

/*
 * ALMA - Atacama Large Millimeter Array
 * (c) European Southern Observatory, 2002
 * (c) Associated Universities Inc., 2002
 * Copyright by ESO (in the framework of the ALMA collaboration),
 * Copyright by AUI (in the framework of the ALMA collaboration),
 * All rights reserved.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY, without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307  USA
 *
 * Warning!
 *  -------------------------------------------------------------------- 
 * | This is generated code!  Do not modify this file.                  |
 * | If you do, all changes will be lost when the file is re-generated. |
 *  --------------------------------------------------------------------
 *
 * File ASDM.h
 */
 
#ifndef ASDM_CLASS
#define ASDM_CLASS

#include <vector>
#include <map>

#include <alma/ASDM/Representable.h>
#include <alma/ASDM/Entity.h>
#include <alma/ASDM/EntityId.h>
#include <alma/ASDM/ArrayTime.h>
#include <alma/ASDM/IllegalAccessException.h>
#include <alma/ASDM/InvalidArgumentException.h>

#include <alma/ASDM/Misc.h>

#ifndef WITHOUT_ACS
#include <asdmIDLC.h> 
#endif

/*\file ASDM.h
    \brief Generated from model's revision "-1", branch ""
*/

namespace asdm {


//class asdm::MainTable;
class MainTable;

//class asdm::AlmaRadiometerTable;
class AlmaRadiometerTable;

//class asdm::AnnotationTable;
class AnnotationTable;

//class asdm::AntennaTable;
class AntennaTable;

//class asdm::CalAmpliTable;
class CalAmpliTable;

//class asdm::CalAntennaSolutionsTable;
class CalAntennaSolutionsTable;

//class asdm::CalAppPhaseTable;
class CalAppPhaseTable;

//class asdm::CalAtmosphereTable;
class CalAtmosphereTable;

//class asdm::CalBandpassTable;
class CalBandpassTable;

//class asdm::CalCurveTable;
class CalCurveTable;

//class asdm::CalDataTable;
class CalDataTable;

//class asdm::CalDelayTable;
class CalDelayTable;

//class asdm::CalDeviceTable;
class CalDeviceTable;

//class asdm::CalFluxTable;
class CalFluxTable;

//class asdm::CalFocusTable;
class CalFocusTable;

//class asdm::CalFocusModelTable;
class CalFocusModelTable;

//class asdm::CalGainTable;
class CalGainTable;

//class asdm::CalHolographyTable;
class CalHolographyTable;

//class asdm::CalPhaseTable;
class CalPhaseTable;

//class asdm::CalPointingTable;
class CalPointingTable;

//class asdm::CalPointingModelTable;
class CalPointingModelTable;

//class asdm::CalPositionTable;
class CalPositionTable;

//class asdm::CalPrimaryBeamTable;
class CalPrimaryBeamTable;

//class asdm::CalReductionTable;
class CalReductionTable;

//class asdm::CalSeeingTable;
class CalSeeingTable;

//class asdm::CalWVRTable;
class CalWVRTable;

//class asdm::ConfigDescriptionTable;
class ConfigDescriptionTable;

//class asdm::CorrelatorModeTable;
class CorrelatorModeTable;

//class asdm::DataDescriptionTable;
class DataDescriptionTable;

//class asdm::DelayModelTable;
class DelayModelTable;

//class asdm::DelayModelFixedParametersTable;
class DelayModelFixedParametersTable;

//class asdm::DelayModelVariableParametersTable;
class DelayModelVariableParametersTable;

//class asdm::DopplerTable;
class DopplerTable;

//class asdm::EphemerisTable;
class EphemerisTable;

//class asdm::ExecBlockTable;
class ExecBlockTable;

//class asdm::FeedTable;
class FeedTable;

//class asdm::FieldTable;
class FieldTable;

//class asdm::FlagTable;
class FlagTable;

//class asdm::FlagCmdTable;
class FlagCmdTable;

//class asdm::FocusTable;
class FocusTable;

//class asdm::FocusModelTable;
class FocusModelTable;

//class asdm::FreqOffsetTable;
class FreqOffsetTable;

//class asdm::GainTrackingTable;
class GainTrackingTable;

//class asdm::HistoryTable;
class HistoryTable;

//class asdm::HolographyTable;
class HolographyTable;

//class asdm::ObservationTable;
class ObservationTable;

//class asdm::PointingTable;
class PointingTable;

//class asdm::PointingModelTable;
class PointingModelTable;

//class asdm::PolarizationTable;
class PolarizationTable;

//class asdm::ProcessorTable;
class ProcessorTable;

//class asdm::PulsarTable;
class PulsarTable;

//class asdm::ReceiverTable;
class ReceiverTable;

//class asdm::SBSummaryTable;
class SBSummaryTable;

//class asdm::ScaleTable;
class ScaleTable;

//class asdm::ScanTable;
class ScanTable;

//class asdm::SeeingTable;
class SeeingTable;

//class asdm::SourceTable;
class SourceTable;

//class asdm::SpectralWindowTable;
class SpectralWindowTable;

//class asdm::SquareLawDetectorTable;
class SquareLawDetectorTable;

//class asdm::StateTable;
class StateTable;

//class asdm::StationTable;
class StationTable;

//class asdm::SubscanTable;
class SubscanTable;

//class asdm::SwitchCycleTable;
class SwitchCycleTable;

//class asdm::SysCalTable;
class SysCalTable;

//class asdm::SysPowerTable;
class SysPowerTable;

//class asdm::TotalPowerTable;
class TotalPowerTable;

//class asdm::WVMCalTable;
class WVMCalTable;

//class asdm::WeatherTable;
class WeatherTable;


//class ASDM : public Representable {
class ASDM {

public:
        ASDM ();
        
        virtual ~ASDM ();
        

        MainTable & getMain () const;

        AlmaRadiometerTable & getAlmaRadiometer () const;

        AnnotationTable & getAnnotation () const;

        AntennaTable & getAntenna () const;

        CalAmpliTable & getCalAmpli () const;

        CalAntennaSolutionsTable & getCalAntennaSolutions () const;

        CalAppPhaseTable & getCalAppPhase () const;

        CalAtmosphereTable & getCalAtmosphere () const;

        CalBandpassTable & getCalBandpass () const;

        CalCurveTable & getCalCurve () const;

        CalDataTable & getCalData () const;

        CalDelayTable & getCalDelay () const;

        CalDeviceTable & getCalDevice () const;

        CalFluxTable & getCalFlux () const;

        CalFocusTable & getCalFocus () const;

        CalFocusModelTable & getCalFocusModel () const;

        CalGainTable & getCalGain () const;

        CalHolographyTable & getCalHolography () const;

        CalPhaseTable & getCalPhase () const;

        CalPointingTable & getCalPointing () const;

        CalPointingModelTable & getCalPointingModel () const;

        CalPositionTable & getCalPosition () const;

        CalPrimaryBeamTable & getCalPrimaryBeam () const;

        CalReductionTable & getCalReduction () const;

        CalSeeingTable & getCalSeeing () const;

        CalWVRTable & getCalWVR () const;

        ConfigDescriptionTable & getConfigDescription () const;

        CorrelatorModeTable & getCorrelatorMode () const;

        DataDescriptionTable & getDataDescription () const;

        DelayModelTable & getDelayModel () const;

        DelayModelFixedParametersTable & getDelayModelFixedParameters () const;

        DelayModelVariableParametersTable & getDelayModelVariableParameters () const;

        DopplerTable & getDoppler () const;

        EphemerisTable & getEphemeris () const;

        ExecBlockTable & getExecBlock () const;

        FeedTable & getFeed () const;

        FieldTable & getField () const;

        FlagTable & getFlag () const;

        FlagCmdTable & getFlagCmd () const;

        FocusTable & getFocus () const;

        FocusModelTable & getFocusModel () const;

        FreqOffsetTable & getFreqOffset () const;

        GainTrackingTable & getGainTracking () const;

        HistoryTable & getHistory () const;

        HolographyTable & getHolography () const;

        ObservationTable & getObservation () const;

        PointingTable & getPointing () const;

        PointingModelTable & getPointingModel () const;

        PolarizationTable & getPolarization () const;

        ProcessorTable & getProcessor () const;

        PulsarTable & getPulsar () const;

        ReceiverTable & getReceiver () const;

        SBSummaryTable & getSBSummary () const;

        ScaleTable & getScale () const;

        ScanTable & getScan () const;

        SeeingTable & getSeeing () const;

        SourceTable & getSource () const;

        SpectralWindowTable & getSpectralWindow () const;

        SquareLawDetectorTable & getSquareLawDetector () const;

        StateTable & getState () const;

        StationTable & getStation () const;

        SubscanTable & getSubscan () const;

        SwitchCycleTable & getSwitchCycle () const;

        SysCalTable & getSysCal () const;

        SysPowerTable & getSysPower () const;

        TotalPowerTable & getTotalPower () const;

        WVMCalTable & getWVMCal () const;

        WeatherTable & getWeather () const;

        virtual std::string toXML() const;
        
        void toXML(std::string directory) const;
        
        virtual void fromXML(std::string xml) ;
                
        static ASDM *getFromXML(std::string xmlDirectory) ;
        
        std::string toMIME();
        
         void setFromMIME(const std::string & /* mimeMsg */);   

        void toFile(std::string directory);

         void setFromFile(std::string directory, bool loadTablesOnDemand);
         
         void setFromFile(std::string directory, const ASDMParseOptions&  parse=ASDMParseOptions());
         
          bool checkRowUniqueness() const ;
        
        #ifndef WITHOUT_ACS

        virtual asdmIDL::ASDMDataSetIDL* toIDL();  
        
        virtual void fromIDL(asdmIDL::ASDMDataSetIDL* x); 
        #endif
                
        virtual Entity getEntity() const;

        virtual void setEntity(Entity e);
        
        virtual std::string getName() const;
        
        virtual unsigned int size() ;
        
#ifndef WITHOUT_ACS

        static ASDM *fromArchive(EntityId datasetId) ;
#endif

#ifndef WITHOUT_ACS

        void updateArchive() const ;
#endif
        
        Representable &getTable(std::string tableName) ;

        
        
        // ===> Attribute timeOfCreation
        
        
        

        
        ArrayTime getTimeOfCreation() const;
        
 
        
        
        void setTimeOfCreation (ArrayTime timeOfCreation);
                
        
        
        


        
        // ===> Attribute version
        
        
        

        
        int getVersion() const;
        
 
        
        
        void setVersion (int version);
                
        
        
        


        
        // ===> Attribute xmlnsPrefix
        
        
        

        
        std::string getXmlnsPrefix() const;
        
 
        
        
        void setXmlnsPrefix (std::string xmlnsPrefix);
                
        
        
        



        enum Origin {
                FILE,  
                ARCHIVE, 
                EX_NIHILO 
        };
        
         Origin getOrigin() const ;
         
         std::string getDirectory() const ;
         
         XSLTransformer & getXSLTransformer() ;
         
private:

        bool archiveAsBin; // If true archive binary else archive XML
        bool fileAsBin ; // If true file binary else file XML           
        bool hasBeenAdded;
        Origin origin;
        bool loadTablesOnDemand_;  // For a dataset which is stored on disk, convert and load in memory only the tables which are used by the code the first time they are referred to.
        bool checkRowUniqueness_;  // For a dataset which is stored on disk, when a table is converted and loaded in memory verify (true) or not (false) the fact that each row is unique.
        std::string directory_;    // The directory where the ASDM has been read. (left empty if the ASDM is only in memory)
                

        MainTable * main;

        AlmaRadiometerTable * almaRadiometer;

        AnnotationTable * annotation;

        AntennaTable * antenna;

        CalAmpliTable * calAmpli;

        CalAntennaSolutionsTable * calAntennaSolutions;

        CalAppPhaseTable * calAppPhase;

        CalAtmosphereTable * calAtmosphere;

        CalBandpassTable * calBandpass;

        CalCurveTable * calCurve;

        CalDataTable * calData;

        CalDelayTable * calDelay;

        CalDeviceTable * calDevice;

        CalFluxTable * calFlux;

        CalFocusTable * calFocus;

        CalFocusModelTable * calFocusModel;

        CalGainTable * calGain;

        CalHolographyTable * calHolography;

        CalPhaseTable * calPhase;

        CalPointingTable * calPointing;

        CalPointingModelTable * calPointingModel;

        CalPositionTable * calPosition;

        CalPrimaryBeamTable * calPrimaryBeam;

        CalReductionTable * calReduction;

        CalSeeingTable * calSeeing;

        CalWVRTable * calWVR;

        ConfigDescriptionTable * configDescription;

        CorrelatorModeTable * correlatorMode;

        DataDescriptionTable * dataDescription;

        DelayModelTable * delayModel;

        DelayModelFixedParametersTable * delayModelFixedParameters;

        DelayModelVariableParametersTable * delayModelVariableParameters;

        DopplerTable * doppler;

        EphemerisTable * ephemeris;

        ExecBlockTable * execBlock;

        FeedTable * feed;

        FieldTable * field;

        FlagTable * flag;

        FlagCmdTable * flagCmd;

        FocusTable * focus;

        FocusModelTable * focusModel;

        FreqOffsetTable * freqOffset;

        GainTrackingTable * gainTracking;

        HistoryTable * history;

        HolographyTable * holography;

        ObservationTable * observation;

        PointingTable * pointing;

        PointingModelTable * pointingModel;

        PolarizationTable * polarization;

        ProcessorTable * processor;

        PulsarTable * pulsar;

        ReceiverTable * receiver;

        SBSummaryTable * sBSummary;

        ScaleTable * scale;

        ScanTable * scan;

        SeeingTable * seeing;

        SourceTable * source;

        SpectralWindowTable * spectralWindow;

        SquareLawDetectorTable * squareLawDetector;

        StateTable * state;

        StationTable * station;

        SubscanTable * subscan;

        SwitchCycleTable * switchCycle;

        SysCalTable * sysCal;

        SysPowerTable * sysPower;

        TotalPowerTable * totalPower;

        WVMCalTable * wVMCal;

        WeatherTable * weather;

        std::vector<Representable *> table;
        
        //vector<Entity *> tableEntity;
        std::map<std::string, Entity> tableEntity;
        
        Entity entity;

        
        
        // ===> Attribute timeOfCreation
        
        

        ArrayTime timeOfCreation;

        
        
        

        
        // ===> Attribute version
        
        

        int version;

        
        
        

        
        // ===> Attribute xmlnsPrefix
        
        

        std::string xmlnsPrefix;

        
        
        

        
        void error() ; // throw(ConversionException);
        static std::string getXMLEntity(EntityId /* id */); // throw(ConversionException);
        static void putXMLEntity(std::string /* xml */); // throw(ConversionException);
        
        XSLTransformer xslTransformer;
        
};

} // End namespace asdm

#endif /* ASDM_CLASS */