AntexReader.hpp

Go to the documentation of this file.

#pragma ident "$Id: AntexReader.hpp 2649 2011-06-09 17:21:12Z architest $"

#ifndef GPSTK_ANTEXREADER_HPP
#define GPSTK_ANTEXREADER_HPP

//============================================================================
//
//  This file is part of GPSTk, the GPS Toolkit.
//
//  The GPSTk 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
//  any later version.
//
//  The GPSTk 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 GPSTk; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  Dagoberto Salazar - gAGE ( http://www.gage.es ). 2009, 2011
//
//============================================================================


#include <string>
#include <map>

#include "Exception.hpp"
#include "FFTextStream.hpp"
#include "StringUtils.hpp"
#include "DayTime.hpp"
#include "SatID.hpp"
#include "Antenna.hpp"


using namespace std;

namespace gpstk
{

   NEW_EXCEPTION_CLASS(InvalidAntex, gpstk::Exception);



   class AntexReader : public FFTextStream
   {
   public:


      static const std::string versionString;      
      static const std::string pcvTypeString;      
      static const std::string commentString;      
      static const std::string endOfHeader;        

      static const std::string startOfAntenna;     
      static const std::string typeSerial;         
      static const std::string calibrationMethod;  
      static const std::string incrementAzimuth;   
      static const std::string zenithGrid;         
      static const std::string numberFreq;         
      static const std::string validFrom;          
      static const std::string validUntil;         
      static const std::string sinexCode;          
      static const std::string startOfFreq;        
      static const std::string antennaEcc;         
      static const std::string endOfFreq;          
      static const std::string startOfFreqRMS;     
      static const std::string antennaEccRMS;      
      static const std::string endOfFreqRMS;       
      static const std::string endOfAntenna;       



      enum pcvType
      {
         absolute = 1,           
         relative,               
         Unknown                 
      };


      AntexReader()
         : fileName(""), version(1.3), valid(false)
      {};


      AntexReader(const char* fn)
         : FFTextStream( fn, std::ios::in )
      { fileName = fn; loadHeader(); };


      AntexReader(const string& fn)
         : FFTextStream( fn.c_str(), std::ios::in )
      { fileName = fn; loadHeader(); };


      virtual void open(const char* fn);


      virtual void open(const string& fn);


      virtual Antenna getAntennaNoRadome(const string& model)
         throw(ObjectNotFound);


      virtual Antenna getAntenna(const string& model)
         throw(ObjectNotFound);


      virtual Antenna getAntenna( const string& model,
                                  const string& serial )
         throw(ObjectNotFound);


      virtual Antenna getAntenna( const string& model,
                                  const string& serial,
                                  const DayTime& epoch )
         throw(ObjectNotFound);


      virtual Antenna getAntenna( const string& serial,
                                  const DayTime& epoch )
         throw(ObjectNotFound);


      bool isValid() const
      { return valid; };


      double getVersion() const
      { return version; };


      bool isAbsolute() const;


      virtual void dump(std::ostream& s) const;


      virtual ~AntexReader() {};


   private:


         // Handy antenna data types

         // Validity:Antennas
      typedef std::map< DayTime, Antenna > ValAntMap;

         // Calibration:Validity:Antennas
      typedef std::map< string, ValAntMap > CalValAntMap;

         // Serial:Calibration:Validity:Antennas
      typedef std::map< string, CalValAntMap > SerCalValAntMap;

         // Radome:Serial:Calibration:Validity:Antennas
      typedef std::map< string, SerCalValAntMap > RSCalValAntMap;

         // Model:Radome:Serial:Calibration:Validity:Antennas
      typedef std::map< string, RSCalValAntMap > AntennaDataMap;


      AntennaDataMap antennaMap;


      string fileName;

      double version;

      SatID::SatelliteSystem system;

      pcvType type;

      std::string refAntena;

      std::string refAntenaSerial;

      std::vector<std::string> commentList;

      bool valid;


      string parseHeaderLine( const std::string& line )
         throw(InvalidAntex);


      Antenna fillAntennaData( const std::string& firstLine );


      virtual void loadHeader(void)
         throw( InvalidAntex,
                FFStreamError,
                gpstk::StringUtils::StringException );


   }; // End of class 'AntexReader'


   inline std::ostream& operator<<( std::ostream& s,
                                    const AntexReader& antread )
   {

         // Call dump() method
      antread.dump(s);

      return s;

   }  // End of operator '<<'


}  // End of namespace gpstk

#endif  // GPSTK_ANTEXREADER_HPP

---