FileFilterFrameWithHeader.hpp

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.
//
//==============================================================================
 
#ifndef GNSSTK_FILEFILTERFRAMEWITHHEADER_HPP
#define GNSSTK_FILEFILTERFRAMEWITHHEADER_HPP
 
#include "Rinex3ObsData.hpp"
#include "FileFilterFrame.hpp"
#include <math.h>
 
namespace gnsstk
{
 
 
   template <class FileStream, class FileData, class FileHeader>
   class FileFilterFrameWithHeader :
      public FileFilterFrame<FileStream, FileData>
   {
   public:
      FileFilterFrameWithHeader(const gnsstk::CommonTime& start =
                                gnsstk::CommonTime::BEGINNING_OF_TIME,
                                const gnsstk::CommonTime& end =
                                gnsstk::CommonTime::END_OF_TIME)
            : FileFilterFrame<FileStream, FileData>(start, end)
      {}
 
      FileFilterFrameWithHeader(const std::vector<std::string>& fileList,
                                const gnsstk::CommonTime& start =
                                gnsstk::CommonTime::BEGINNING_OF_TIME,
                                const gnsstk::CommonTime& end =
                                gnsstk::CommonTime::END_OF_TIME)
            : FileFilterFrame<FileStream, FileData>(fileList, start, end)
      {
         std::vector<std::string>::const_iterator itr = fileList.begin();
         while (itr != fileList.end())
         {
            this->fs.newSpec(*itr);
            init();
            itr++;
         }
      }
 
      FileFilterFrameWithHeader(const std::string& filename,
                                const gnsstk::CommonTime& start =
                                gnsstk::CommonTime::BEGINNING_OF_TIME,
                                const gnsstk::CommonTime& end =
                                gnsstk::CommonTime::END_OF_TIME)
            : FileFilterFrame<FileStream, FileData>(filename, start, end)
      {init();}
 
      FileFilterFrameWithHeader(const FileSpec& spec,
                                const gnsstk::CommonTime& start =
                                gnsstk::CommonTime::BEGINNING_OF_TIME,
                                const gnsstk::CommonTime& end =
                                gnsstk::CommonTime::END_OF_TIME,
                                const FileSpecFind::Filter& filter =
                                FileSpecFind::Filter())
            : FileFilterFrame<FileStream, FileData>(spec, start, end, filter)
      {init(filter);}
 
      FileFilterFrameWithHeader&
      newSource(const FileSpec& filespec,
                const gnsstk::CommonTime& start =
                gnsstk::CommonTime::BEGINNING_OF_TIME,
                const gnsstk::CommonTime& end =
                gnsstk::CommonTime::END_OF_TIME,
                const FileSpecFind::Filter& filter =
                FileSpecFind::Filter())
      {
         FileFilterFrame<FileStream, FileData>::newSource(filespec, start,
                                                          end, filter);
         init(filter);
         return *this;
      }
 
      FileFilterFrameWithHeader&
      newSource(const std::string& filename,
                const gnsstk::CommonTime& start =
                gnsstk::CommonTime::BEGINNING_OF_TIME,
                const gnsstk::CommonTime& end =
                gnsstk::CommonTime::END_OF_TIME)
      {
         FileFilterFrame<FileStream, FileData>::newSource(filename, start,
                                                          end);
         init();
         return *this;
      }
 
      FileFilterFrameWithHeader&
      newSource(const std::vector<std::string>& fileList,
                const gnsstk::CommonTime& start =
                gnsstk::CommonTime::BEGINNING_OF_TIME,
                const gnsstk::CommonTime& end =
                gnsstk::CommonTime::END_OF_TIME)
      {
         FileFilterFrame<FileStream, FileData>::newSource(fileList, start,
                                                          end);
         typename std::vector<std::string>::const_iterator itr;
         for (itr = fileList.begin(); itr != fileList.end(); itr++)
         {
            this->fs.newSpec(*itr);
            init();
         }
         return *this;
      }
 
      virtual ~FileFilterFrameWithHeader() {}
 
      bool writeFile(const std::string& outputFile,
                     const FileHeader& fh) const;
 
      template <class BinaryPredicate>
      std::list<FileData>
      halfDiff(const FileFilterFrameWithHeader<FileStream,FileData,FileHeader>& r,
               BinaryPredicate p,
               int precision) const
      {
         long double epsilon = 1 / std::pow((long double)10,precision);
         std::list<FileData> toReturn;
 
         typename std::list<FileData>::const_iterator dvIt = this->dataVec.begin();
         typename std::list<FileData>::const_iterator rdvIt = r.dataVec.begin();
         while(dvIt != this->dataVec.end())
         {
            if (rdvIt == r.dataVec.end() ||
                p( *dvIt, this->headerList.front(),
                   *rdvIt, r.headerList.front(),
                   epsilon)) //dv less than
            {
               toReturn.push_back(*dvIt);
               dvIt++;
            }
            else if (p(*rdvIt, r.headerList.front(),
                       *dvIt, this->headerList.front(),
                       epsilon)) //rdv less than
            {
               rdvIt++;
            }
            else //equal
            {
               dvIt++;
               rdvIt++;
            }
         }
         return toReturn;
      }
 
      template <class Operation>
      FileFilterFrameWithHeader& touchHeader(Operation& op)
      {
         typename std::list<FileHeader>::iterator itr = headerList.begin();
 
         while (itr != headerList.end())
         {
            op(*itr);
            itr++;
         }
 
         return *this;
      }
 
      std::list<FileHeader>& getHeaderData(void) {return headerList;}
 
      std::list<FileHeader> getHeaderData(void) const {return headerList;}
 
      typename std::list<FileHeader>::size_type getHeaderCount(void) const
      { return headerList.size(); }
 
      typename std::list<FileHeader>::const_iterator beginHeader() const;
 
      typename std::list<FileHeader>::const_iterator endHeader() const;
 
      typename std::list<FileHeader>::iterator beginHeader();
 
      typename std::list<FileHeader>::iterator endHeader();
 
      bool emptyHeader() const
      { return headerList.empty(); }
 
      typename std::list<FileHeader>::size_type sizeHeader()
      { return headerList.size(); }
 
      FileHeader& frontHeader();
 
      const FileHeader& frontHeader() const;
 
      FileHeader& backHeader();
 
      const FileHeader& backHeader() const;
 
   protected:
      void init(const FileSpecFind::Filter& filter = FileSpecFind::Filter());
 
      inline void chl(const std::string& req)
      {
         gnsstk::InvalidRequest exc("Header list is empty attempting to"
                                   " satisfy "+req+" request.");
         if (headerList.empty())
         {
            GNSSTK_THROW(exc);
         }
      }
 
   protected:
      std::list<FileHeader> headerList;
   };
 
 
   template <class FileStream, class FileData, class FileHeader>
   bool FileFilterFrameWithHeader<FileStream,FileData,FileHeader>::
   writeFile(const std::string& outputFile,
             const FileHeader& fh) const
   {
         // make the directory (if needed)
      std::string::size_type pos = outputFile.rfind('/');
 
      if (pos != std::string::npos)
         gnsstk::FileUtils::makeDir(outputFile.substr(0,pos).c_str(), 0755);
 
      FileStream stream(outputFile.c_str(), std::ios::out|std::ios::trunc);
      stream.exceptions(std::ios::failbit);
 
      stream << fh;
 
      typename std::list<FileData>::const_iterator index;
      for(index = this->dataVec.begin(); index != this->dataVec.end(); index++)
         stream << (*index);
      return true;
   }
 
   template <class FileStream, class FileData, class FileHeader>
   typename std::list<FileHeader>::const_iterator
   FileFilterFrameWithHeader<FileStream,FileData,FileHeader>::beginHeader()
      const
   {
      try { chl("beginHeader"); }
      catch(gnsstk::InvalidRequest exc)
      { GNSSTK_RETHROW(exc); }
      return headerList.begin();
   }
 
   template <class FileStream, class FileData, class FileHeader>
   typename std::list<FileHeader>::const_iterator
   FileFilterFrameWithHeader<FileStream,FileData,FileHeader>::endHeader()
      const
   {
      try { chl("endHeader"); }
      catch(gnsstk::InvalidRequest exc)
      { GNSSTK_RETHROW(exc); }
      return headerList.end();
   }
 
   template <class FileStream, class FileData, class FileHeader>
   typename std::list<FileHeader>::iterator
   FileFilterFrameWithHeader<FileStream,FileData,FileHeader>::beginHeader()
   {
      try { chl("beginHeader"); }
      catch(gnsstk::InvalidRequest exc)
      { GNSSTK_RETHROW(exc); }
      return headerList.begin();
   }
 
 
   template <class FileStream, class FileData, class FileHeader>
   typename std::list<FileHeader>::iterator
   FileFilterFrameWithHeader<FileStream,FileData,FileHeader>::endHeader()
   {
      try { chl("endHeader"); }
      catch(gnsstk::InvalidRequest exc)
      { GNSSTK_RETHROW(exc); }
      return headerList.end();
   }
 
   template <class FileStream, class FileData, class FileHeader>
   FileHeader&
   FileFilterFrameWithHeader<FileStream,FileData,FileHeader>::frontHeader()
   {
      try { chl("frontHeader"); }
      catch(gnsstk::InvalidRequest exc)
      { GNSSTK_RETHROW(exc); }
      return headerList.front();
   }
 
 
   template <class FileStream, class FileData, class FileHeader>
   const FileHeader&
   FileFilterFrameWithHeader<FileStream,FileData,FileHeader>::frontHeader()
      const
   {
      try { chl("frontHeader"); }
      catch(gnsstk::InvalidRequest exc)
      { GNSSTK_RETHROW(exc); }
      return headerList.front();
   }
 
 
   template <class FileStream, class FileData, class FileHeader>
   FileHeader&
   FileFilterFrameWithHeader<FileStream,FileData,FileHeader>::backHeader()
   {
      try { chl("backHeader"); }
      catch(gnsstk::InvalidRequest exc)
      { GNSSTK_RETHROW(exc); }
      return headerList.back();
   }
 
 
   template <class FileStream, class FileData, class FileHeader>
   const FileHeader&
   FileFilterFrameWithHeader<FileStream,FileData,FileHeader>::backHeader()
      const
   {
      try { chl("backHeader"); }
      catch(gnsstk::InvalidRequest exc)
      { GNSSTK_RETHROW(exc); }
      return headerList.back();
   }
 
   template <class FileStream, class FileData, class FileHeader>
   void
   FileFilterFrameWithHeader<FileStream,FileData,FileHeader> ::
   init(const FileSpecFind::Filter& filter)
   {
         // find the files
      std::list<std::string> listOfFiles =
         FileSpecFind::find(this->fs, this->startTime, this->endTime, filter);
 
         // for each file, just read the header
      for (const auto& i : listOfFiles)
      {
         FileStream s(i.c_str());
 
         if (s.good())
         {
            s.exceptions(std::ios::failbit);
 
            FileHeader header;
            s >> header;
            headerList.push_back(header);
         }
      }
   }
 
} // namespace gnsstk
 
#endif //GNSSTK_FILEFILTERFRAMEWITHHEADER_HPP