AntexHeader.cpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk 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 3.0 of the License, or
//  any later version.
//
//  The GNSSTk 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 GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin, under contract to an agency or agencies
//  within the U.S. Department of Defense. The U.S. Government retains all
//  rights to use, duplicate, distribute, disclose, or release this software.
//
//  Pursuant to DoD Directive 523024
//
//  DISTRIBUTION STATEMENT A: This software has been approved for public
//                            release, distribution is unlimited.
//
//==============================================================================
 
 
#include "AntexHeader.hpp"
#include "AntexStream.hpp"
#include "StringUtils.hpp"
 
using namespace std;
using namespace gnsstk::StringUtils;
 
namespace gnsstk
{
   const string AntexHeader::versionString       = "ANTEX VERSION / SYST";
   const string AntexHeader::pcvTypeString       = "PCV TYPE / REFANT";
   const string AntexHeader::headerCommentString = "COMMENT";
   const string AntexHeader::endOfHeaderString   = "END OF HEADER";
 
   void AntexHeader::reallyPutRecord(FFStream& ffs) const
   {
      AntexStream &strm = dynamic_cast<AntexStream &>(ffs);
 
      strm.header = *this;
 
      unsigned long allValid;
      if (version == 1.3 || version == 1.4)
      {
         allValid = allValid13;
      }
      else
      {
         FFStreamError err("Unknown Antex version: " + asString(version, 2));
         err.addText("Make sure to set the version correctly.");
         GNSSTK_THROW(err);
      }
 
      if ((valid & allValid) != allValid)
      {
         FFStreamError err("Incomplete or invalid header.");
         err.addText(
            "Set all header valid bits for all of the available data.");
         GNSSTK_THROW(err);
      }
 
      try
      {
         WriteHeaderRecords(strm);
      }
      catch (FFStreamError& e)
      {
         GNSSTK_RETHROW(e);
      }
      catch (StringException& e)
      {
         GNSSTK_RETHROW(e);
      }
 
   } // end AntexHeader::reallyPutRecord
 
      // this function writes all valid header records
   void AntexHeader::WriteHeaderRecords(FFStream& ffs) const
   {
      AntexStream &strm = dynamic_cast<AntexStream &>(ffs);
      string line;
 
      if ((valid & versionValid) | systemValid)
      {
         line = rightJustify(asString(version, 1), 8);
         line += string(12, ' ');
         line += system;
         line = leftJustify(line, 60);
         line += versionString;
         strm << leftJustify(line, 80) << endl;
         strm.lineNumber++;
      }
      if (valid & pcvTypeValid)
      {
         line = pcvType;
         line += string(19, ' ');
         line += leftJustify(refAntType, 20);
         line += leftJustify(refAntSerNum, 20);
         line += pcvTypeString;
         strm << leftJustify(line, 80) << endl;
         strm.lineNumber++;
      }
      if (valid & commentValid)
      {
         vector<string>::const_iterator itr = commentList.begin();
         while (itr != commentList.end())
         {
            line = leftJustify((*itr), 60);
            line += headerCommentString;
            strm << leftJustify(line, 80) << endl;
            strm.lineNumber++;
            itr++;
         }
      }
      if (valid & endValid)
      {
         line = string(60, ' ');
         line += endOfHeaderString;
         strm << leftJustify(line, 80) << endl;
         strm.lineNumber++;
      }
   } // end AntexHeader::WriteHeaderRecords()
 
      // this function parses a single header record
   void AntexHeader::ParseHeaderRecord(string& line)
   {
      string label(line, 60, 20);
 
      if (label == versionString)
      {
         version = asDouble(line.substr(0, 8));
         system  = line[20];
         if (system != ' ' && system != 'G' && system != 'R' && system != 'E' &&
             system != 'C' && system != 'M')
         {
            stringstream os;
            os >> system;
            FFStreamError e("Satellite system is invalid: " + os.str());
            GNSSTK_THROW(e);
         }
         valid |= versionValid;
         valid |= systemValid;
      }
      else if (label == pcvTypeString)
      {
         pcvType = line[0];
         if (pcvType != 'A' && pcvType != 'R')
         {
            stringstream os;
            os >> pcvType;
            FFStreamError e("PCV type is invalid: " + os.str());
            GNSSTK_THROW(e);
         }
         refAntType   = line.substr(20, 20);
         refAntSerNum = line.substr(40, 20);
         valid |= pcvTypeValid;
      }
      else if (label == headerCommentString)
      {
         commentList.push_back(stripTrailing(line.substr(0, 60)));
         valid |= commentValid;
      }
      else if (label == endOfHeaderString)
      {
         valid |= endValid;
      }
      else
      {
         FFStreamError e("Unidentified label: " + label);
         GNSSTK_THROW(e);
      }
   } // end of AntexHeader::ParseHeaderRecord(string& line)
 
      // This function parses the entire header from the given stream
   void AntexHeader::reallyGetRecord(FFStream& ffs)
   {
      AntexStream &strm = dynamic_cast<AntexStream &>(ffs);
 
         // if already read, just return
      if (strm.headerRead == true)
      {
         return;
      }
 
         /* since we're reading a new header, we need to reinitialize
            all our list structures.  all the other objects should be ok.
            this also applies if we threw an exception the first time we read
            the header and are now re-reading it. some of these could be full
            and we need to empty them. */
      commentList.clear();
      valid = 0;
 
      string line;
      while (!(valid & endValid))
      {
         strm.formattedGetLine(line);
         stripTrailing(line);
 
         if (line.length() == 0)
         {
            continue;
         }
         else if (line.length() < 60 || line.length() > 80)
         {
            FFStreamError e("Invalid line length");
            GNSSTK_THROW(e);
         }
 
         try
         {
            ParseHeaderRecord(line);
         }
         catch (FFStreamError& e)
         {
            GNSSTK_RETHROW(e);
         }
 
      } // end while(not end of header)
 
      unsigned long allValid;
      if (version == 1.3 || version == 1.4)
      {
         allValid = allValid13;
      }
      else
      {
         FFStreamError e("Unknown or unsupported Antex version " +
                         asString(version));
         GNSSTK_THROW(e);
      }
 
      if ((allValid & valid) != allValid)
      {
         FFStreamError e("Incomplete or invalid header");
         GNSSTK_THROW(e);
      }
 
         // If we get here, we should have reached the end of header line
      strm.header     = *this;
      strm.headerRead = true;
 
   } // end of reallyGetRecord()
 
   void AntexHeader::dump(ostream& s) const
   {
      s << "Dump of AntexHeader, version " << fixed << setprecision(1)
        << version << " system " << system << endl;
      s << "These are " << (pcvType == 'A' ? "absolute" : "relative")
        << " phase center offsets.\n";
      s << "Reference antenna: type " << refAntType << ", serial no. "
        << refAntSerNum << endl;
 
      for (size_t i = 0; i < commentList.size(); i++)
      {
         if (i == 0)
         {
            s << "Comments:\n";
         }
         s << "Comment " << setw(2) << i + 1 << ": " << commentList[i] << endl;
      }
      s << "End of AntexHeader dump" << endl;
   }
 
} // namespace gnsstk