ASDM.h

/*
 * 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>
using std::vector;

#include <map>
using std::map;

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

using asdm::Entity;
using asdm::EntityId;
using asdm::ArrayTime;
using asdm::IllegalAccessException;
using asdm::InvalidArgumentException;

#ifndef WITHOUT_ACS
#include <asdmIDLC.h> 
using namespace asdmIDL;   
#endif

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

namespace asdm {


//class asdm::MainTable;
class MainTable;

//class asdm::AlmaRadiometerTable;
class AlmaRadiometerTable;

//class asdm::AntennaTable;
class AntennaTable;

//class asdm::BeamTable;
class BeamTable;

//class asdm::CalAmpliTable;
class CalAmpliTable;

//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::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::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::ReceiverTable;
class ReceiverTable;

//class asdm::SBSummaryTable;
class SBSummaryTable;

//class asdm::ScanTable;
class ScanTable;

//class asdm::SeeingTable;
class SeeingTable;

//class asdm::SourceTable;
class SourceTable;

//class asdm::SourceParameterTable;
class SourceParameterTable;

//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::TotalPowerTable;
class TotalPowerTable;

//class asdm::WVMCalTable;
class WVMCalTable;

//class asdm::WeatherTable;
class WeatherTable;


class ASDM : public Representable {

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

        MainTable & getMain () const;

        AlmaRadiometerTable & getAlmaRadiometer () const;

        AntennaTable & getAntenna () const;

        BeamTable & getBeam () const;

        CalAmpliTable & getCalAmpli () 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;

        DopplerTable & getDoppler () const;

        EphemerisTable & getEphemeris () const;

        ExecBlockTable & getExecBlock () const;

        FeedTable & getFeed () const;

        FieldTable & getField () 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;

        ReceiverTable & getReceiver () const;

        SBSummaryTable & getSBSummary () const;

        ScanTable & getScan () const;

        SeeingTable & getSeeing () const;

        SourceTable & getSource () const;

        SourceParameterTable & getSourceParameter () const;

        SpectralWindowTable & getSpectralWindow () const;

        SquareLawDetectorTable & getSquareLawDetector () const;

        StateTable & getState () const;

        StationTable & getStation () const;

        SubscanTable & getSubscan () const;

        SwitchCycleTable & getSwitchCycle () const;

        SysCalTable & getSysCal () const;

        TotalPowerTable & getTotalPower () const;

        WVMCalTable & getWVMCal () const;

        WeatherTable & getWeather () const;

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

        void toFile(string directory);

         void setFromFile(string directory);
        
        #ifndef WITHOUT_ACS

        virtual ASDMDataSetIDL* toIDL();  
        
        virtual void fromIDL(ASDMDataSetIDL* x); 
        #endif
        
        virtual string toVOTable() const throw(ConversionException);
        virtual void fromVOTable(string vo) throw(ConversionException);
        
        virtual char * toFITS() const throw(ConversionException);
        virtual void fromFITS(char * fits) throw(ConversionException);
        
        virtual Entity getEntity() const;

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

        static ASDM *fromArchive(EntityId datasetId) throw(ConversionException);
#endif

#ifndef WITHOUT_ACS

        void updateArchive() const throw(ConversionException);
#endif
        
        Representable &getTable(string tableName) throw(InvalidArgumentException);

        
        
        // ===> Attribute timeOfCreation
        
        
        

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



private:

        bool archiveAsBin; // If true archive binary else archive XML
        bool fileAsBin ; // If true file binary else file XML           
        

        MainTable * main;

        AlmaRadiometerTable * almaRadiometer;

        AntennaTable * antenna;

        BeamTable * beam;

        CalAmpliTable * calAmpli;

        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;

        DopplerTable * doppler;

        EphemerisTable * ephemeris;

        ExecBlockTable * execBlock;

        FeedTable * feed;

        FieldTable * field;

        FlagCmdTable * flagCmd;

        FocusTable * focus;

        FocusModelTable * focusModel;

        FreqOffsetTable * freqOffset;

        GainTrackingTable * gainTracking;

        HistoryTable * history;

        HolographyTable * holography;

        ObservationTable * observation;

        PointingTable * pointing;

        PointingModelTable * pointingModel;

        PolarizationTable * polarization;

        ProcessorTable * processor;

        ReceiverTable * receiver;

        SBSummaryTable * sBSummary;

        ScanTable * scan;

        SeeingTable * seeing;

        SourceTable * source;

        SourceParameterTable * sourceParameter;

        SpectralWindowTable * spectralWindow;

        SquareLawDetectorTable * squareLawDetector;

        StateTable * state;

        StationTable * station;

        SubscanTable * subscan;

        SwitchCycleTable * switchCycle;

        SysCalTable * sysCal;

        TotalPowerTable * totalPower;

        WVMCalTable * wVMCal;

        WeatherTable * weather;

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

        
        
        // ===> Attribute timeOfCreation
        
        

        ArrayTime timeOfCreation;

        
        
        

        
        void error() throw(ConversionException);
        static string getXMLEntity(EntityId id) throw(ConversionException);
        static void putXMLEntity(string xml) throw(ConversionException);
        
};

} // End namespace asdm

#endif /* ASDM_CLASS */

---