TagType.h

Go to the documentation of this file.

#ifndef TagType_CLASS
#define TagType_CLASS
#include <string>
#include <map>
#include <iostream>

namespace asdm {
class TagType {
 public:
  virtual std::string toString() const;
  
  static const TagType* getTagType(std::string name);
  
  static const TagType* NoType;
  

        

        
        static const TagType*  AlmaRadiometer ;
        

        
        static const TagType*  Annotation ;
        

        
        static const TagType*  Antenna ;
        

        

        

        

        

        

        

        
        static const TagType*  CalData ;
        

        

        

        

        

        

        

        

        

        

        

        

        

        
        static const TagType*  CalReduction ;
        

        

        

        
        static const TagType*  ConfigDescription ;
        

        
        static const TagType*  CorrelatorMode ;
        

        
        static const TagType*  DataDescription ;
        

        

        
        static const TagType*  DelayModelFixedParameters ;
        

        
        static const TagType*  DelayModelVariableParameters ;
        

        
        static const TagType*  Doppler ;
        

        

        
        static const TagType*  ExecBlock ;
        

        
        static const TagType*  Feed ;
        

        
        static const TagType*  Field ;
        

        
        static const TagType*  Flag ;
        

        

        

        
        static const TagType*  FocusModel ;
        

        

        

        

        
        static const TagType*  Holography ;
        

        
        static const TagType*  Observation ;
        

        

        
        static const TagType*  PointingModel ;
        

        
        static const TagType*  Polarization ;
        

        
        static const TagType*  Processor ;
        

        
        static const TagType*  Pulsar ;
        

        
        static const TagType*  Receiver ;
        

        
        static const TagType*  SBSummary ;
        

        
        static const TagType*  Scale ;
        

        

        

        
        static const TagType*  Source ;
        

        
        static const TagType*  SpectralWindow ;
        

        
        static const TagType*  SquareLawDetector ;
        

        
        static const TagType*  State ;
        

        
        static const TagType*  Station ;
        

        

        
        static const TagType*  SwitchCycle ;
        

        

        

        

        

        

 

 private:
  std::string name;
  static std::map<std::string,const TagType*> name2TagType;
  virtual ~TagType() {};
  TagType(std::string name);
  
  class TagTypeMgr {
  public:
        ~TagTypeMgr () {
        if (TagType::NoType) {delete TagType::NoType; TagType::NoType=0;}

        

        
        if (TagType:: AlmaRadiometer) { delete TagType::AlmaRadiometer; TagType::AlmaRadiometer = 0; }
        

        
        if (TagType:: Annotation) { delete TagType::Annotation; TagType::Annotation = 0; }
        

        
        if (TagType:: Antenna) { delete TagType::Antenna; TagType::Antenna = 0; }
        

        

        

        

        

        

        

        
        if (TagType:: CalData) { delete TagType::CalData; TagType::CalData = 0; }
        

        

        

        

        

        

        

        

        

        

        

        

        

        
        if (TagType:: CalReduction) { delete TagType::CalReduction; TagType::CalReduction = 0; }
        

        

        

        
        if (TagType:: ConfigDescription) { delete TagType::ConfigDescription; TagType::ConfigDescription = 0; }
        

        
        if (TagType:: CorrelatorMode) { delete TagType::CorrelatorMode; TagType::CorrelatorMode = 0; }
        

        
        if (TagType:: DataDescription) { delete TagType::DataDescription; TagType::DataDescription = 0; }
        

        

        
        if (TagType:: DelayModelFixedParameters) { delete TagType::DelayModelFixedParameters; TagType::DelayModelFixedParameters = 0; }
        

        
        if (TagType:: DelayModelVariableParameters) { delete TagType::DelayModelVariableParameters; TagType::DelayModelVariableParameters = 0; }
        

        
        if (TagType:: Doppler) { delete TagType::Doppler; TagType::Doppler = 0; }
        

        

        
        if (TagType:: ExecBlock) { delete TagType::ExecBlock; TagType::ExecBlock = 0; }
        

        
        if (TagType:: Feed) { delete TagType::Feed; TagType::Feed = 0; }
        

        
        if (TagType:: Field) { delete TagType::Field; TagType::Field = 0; }
        

        
        if (TagType:: Flag) { delete TagType::Flag; TagType::Flag = 0; }
        

        

        

        
        if (TagType:: FocusModel) { delete TagType::FocusModel; TagType::FocusModel = 0; }
        

        

        

        

        
        if (TagType:: Holography) { delete TagType::Holography; TagType::Holography = 0; }
        

        
        if (TagType:: Observation) { delete TagType::Observation; TagType::Observation = 0; }
        

        

        
        if (TagType:: PointingModel) { delete TagType::PointingModel; TagType::PointingModel = 0; }
        

        
        if (TagType:: Polarization) { delete TagType::Polarization; TagType::Polarization = 0; }
        

        
        if (TagType:: Processor) { delete TagType::Processor; TagType::Processor = 0; }
        

        
        if (TagType:: Pulsar) { delete TagType::Pulsar; TagType::Pulsar = 0; }
        

        
        if (TagType:: Receiver) { delete TagType::Receiver; TagType::Receiver = 0; }
        

        
        if (TagType:: SBSummary) { delete TagType::SBSummary; TagType::SBSummary = 0; }
        

        
        if (TagType:: Scale) { delete TagType::Scale; TagType::Scale = 0; }
        

        

        

        
        if (TagType:: Source) { delete TagType::Source; TagType::Source = 0; }
        

        
        if (TagType:: SpectralWindow) { delete TagType::SpectralWindow; TagType::SpectralWindow = 0; }
        

        
        if (TagType:: SquareLawDetector) { delete TagType::SquareLawDetector; TagType::SquareLawDetector = 0; }
        

        
        if (TagType:: State) { delete TagType::State; TagType::State = 0; }
        

        
        if (TagType:: Station) { delete TagType::Station; TagType::Station = 0; }
        

        

        
        if (TagType:: SwitchCycle) { delete TagType::SwitchCycle; TagType::SwitchCycle = 0; }
        

        

        

        

        

        
                
        };
        
        TagTypeMgr() {};
        
  private :
        TagTypeMgr(const TagTypeMgr&);
        TagTypeMgr & operator=(const TagTypeMgr&);
  };
  static TagTypeMgr tagTypeMgr;
};
} // end namespace asdm
#endif /* TagType_CLASS */