RTFileFrame.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_RTFILEFRAME_HPP
#define GNSSTK_RTFILEFRAME_HPP
 
#include <sys/types.h>
#include <sys/stat.h>
#include <iterator>
#include "FileSpec.hpp"
#include "FileFilter.hpp"
 
namespace gnsstk
{
 
 
   class RTFileFrameHelper
   {
   public:
      enum GetRecordMode
      {
         Dumb  = 0, 
         Smart = 1  
      };
 
      enum FileReadingMode
      {
         AppendedData = 0,     
         FromTheBeginning = 1  
      };
   };
 
      // forward declaration of the RTFileFrame class
   template <class FileStream, class FileData>
   class RTFileFrame;
 
   template <class FileStream, class FileData>
   class RTFileFrameIterator
   {
   public:
      RTFileFrameIterator()
            : rtff(NULL)
      {}
 
      RTFileFrameIterator(const RTFileFrameIterator& right)
            : rtff(right.rtff)
      {}
 
      virtual ~RTFileFrameIterator() {}
 
      RTFileFrameIterator& operator=(const RTFileFrameIterator& r)
      {
         rtff = r.rtff;
         return *this;
      }
 
      RTFileFrameIterator operator++()
      {
         rtff->getRecord();
         return *this;
      }
 
      RTFileFrameIterator operator++(int)
      {
         RTFileFrameIterator<FileStream, FileData> temp = *this;
         read();
         return temp;
      }
 
      const FileData& operator*() const
      {
         return rtff->lastData;
      }
 
      const FileData* operator->() const
      {
         return &(rtff->lastData);
      }
 
      bool operator==(const RTFileFrameIterator& right) const
      {
         if (rtff == right.rtff)
         {
            if (rtff == NULL)
               return true;
 
            if ((rtff->isOK == right.rtff->isOK) ||
                (!rtff->isOK && (right.rtff->fileStream == rtff->fileStream)))
               return true;
            return false;
         }
         else if ((rtff == NULL) && (right.rtff))
            return !right.rtff->isOK;
         else if ((right.rtff == NULL) && (rtff))
            return !rtff->isOK;
         else
            return false;
      }
 
      bool operator!=(const RTFileFrameIterator& right) const
      { return !(*this == right);}
 
      friend class RTFileFrame<FileStream, FileData>;
 
   protected:
      void read()
      { rtff->getRecord(); }
 
   private:
      RTFileFrameIterator(gnsstk::RTFileFrame<FileStream, FileData>& r)
            : rtff(&r)
      { rtff->getRecord(); }
 
      gnsstk::RTFileFrame<FileStream, FileData>* rtff;
   };
 
   template <class FileStream, class FileData>
   class RTFileFrame : public RTFileFrameHelper
   {
   public:
      RTFileFrame(const gnsstk::FileSpec& fnFormat,
                  const gnsstk::CommonTime& beginning = gnsstk::CommonTime::BEGINNING_OF_TIME,
                  const gnsstk::CommonTime& ending = gnsstk::CommonTime::END_OF_TIME,
                  const RTFileFrameHelper::FileReadingMode frm = AppendedData,
                  const RTFileFrameHelper::GetRecordMode grm = Dumb);
 
      ~RTFileFrame();
 
      RTFileFrame& setFileReadingMode(const FileReadingMode f);
 
      RTFileFrame& setGetRecordMode(const GetRecordMode g);
 
      void waitForData(unsigned wait = 0);
 
      bool hasFileChanged();
 
      bool endOfDataSet();
 
      RTFileFrameIterator<FileStream, FileData> end();
 
      RTFileFrameIterator<FileStream, FileData> begin();
 
      bool getRecord();
 
      void openNextDay();
 
      const FileData& data() const { return lastData;}
 
      std::list<FileData> getList() const;
 
      FileFilter<FileData> getFileFilter() const;
 
      std::string getCurrentFile() const {return currentFileName;}
 
      gnsstk::CommonTime getCurrentTime() const {return currentTime;}
 
      friend class RTFileFrameIterator<FileStream, FileData>;
 
      bool openCurrentFile();
 
      void closeCurrentFile();
 
   protected:
      FileStream* fileStream;
 
      FileData lastData;
      std::streampos lastPosition;
      std::string currentFileName;
      gnsstk::FileSpec fs;
 
      gnsstk::CommonTime startTime, 
         currentTime,            
         endTime;                
      FileReadingMode readMode;
      GetRecordMode getMode;
      struct stat fileInfo;
      bool isOK;
   };
 
 
   template <class FileStream, class FileData>
   RTFileFrame<FileStream, FileData>::
   RTFileFrame<FileStream, FileData>(const gnsstk::FileSpec& fnFormat,
                                     const gnsstk::CommonTime& beginning,
                                     const gnsstk::CommonTime& ending,
                                     const RTFileFrameHelper::FileReadingMode frm,
                                     const RTFileFrameHelper::GetRecordMode grm)
      : fileStream(NULL), fs(fnFormat), startTime(beginning),
      currentTime(beginning), endTime(ending), readMode(frm), getMode(grm)
   {
         // zero out seconds
      startTime = MJD(floor(MJD(startTime).mjd));
      endTime = MJD(floor(MJD(endTime).mjd));
      currentTime = MJD(floor(MJD(curretnTime).mjd));
 
         // set up the stream
      openCurrentFile();
   }
 
   template <class FileStream, class FileData>
   RTFileFrame<FileStream, FileData>::~RTFileFrame()
   {
      if (fileStream)
      {
         fileStream->close();
         delete fileStream;
      }
   }
 
   template <class FileStream, class FileData>
   RTFileFrame<FileStream, FileData>&
   RTFileFrame<FileStream, FileData> ::
   setFileReadingMode(const RTFileFrameHelper::FileReadingMode f)
   {
      readMode = f;
      return *this;
   }
 
   template <class FileStream, class FileData>
   RTFileFrame<FileStream, FileData>&
   RTFileFrame<FileStream, FileData> ::
   setGetRecordMode(const RTFileFrameHelper::GetRecordMode g)
   {
      getMode = g;
      return *this;
   }
 
   template <class FileStream, class FileData>
   void
   RTFileFrame<FileStream, FileData>::waitForData(unsigned wait)
   {
      sleep(wait);
      if(readMode == AppendedData)
      {
            // reopen the file and skip to where we left off - openCurrentFile
            // will overwrite lastPosition...
         std::streampos cachedPos = lastPosition;
         if(openCurrentFile())
            fileStream->seekg(cachedPos);
         lastPosition = cachedPos;
      }
      else
      {
            // start from the beginning
         openCurrentFile();
      }
   }
 
   template <class FileStream, class FileData>
   bool
   RTFileFrame<FileStream, FileData>::hasFileChanged()
   {
      struct stat tempStat;
      if (stat(currentFileName.c_str(), &tempStat))
         return false;
      if (tempStat.st_mtime != fileInfo.st_mtime)
         return true;
      else
         return false;
   }
 
   template <class FileStream, class FileData>
   bool
   RTFileFrame<FileStream, FileData>::endOfDataSet()
   {
      if (currentTime > endTime)
         return true;
      else
         return false;
   }
 
   template <class FileStream, class FileData>
   RTFileFrameIterator<FileStream, FileData>
   RTFileFrame<FileStream, FileData>::end()
   {
      return RTFileFrameIterator<FileStream, FileData>();
   }
 
   template <class FileStream, class FileData>
   RTFileFrameIterator<FileStream, FileData>
   RTFileFrame<FileStream, FileData>::begin()
   {
      if (readMode == AppendedData)
      {
         ;
      }
      else // if (readMode == FromTheBeginning)
      {
         openCurrentFile();
      }
         // this constructor does not read in the first record, so force it
         // to do so before returning
      RTFileFrameIterator<FileStream, FileData> toReturn(*this);
      return toReturn;
   }
 
   template <class FileStream, class FileData>
   bool
   RTFileFrame<FileStream, FileData>::getRecord()
   {
      if (!isOK)
         return false;
 
         // is the stream still good to read?
      if (*fileStream >> lastData)
      {
         lastPosition = fileStream->tellg();
         return true;
      }
         // the last read failed - try opening the next file until
         // today's file is reched or else return false
      else
      {
            // read the next file or not?
         if (getMode == Smart)
         {
            if (!endOfDataSet())
            {
                  // still before today?
               gnsstk::CommonTime today;
               today.setYDoySod(today.year(), today.DOY(), 0);
 
               if (currentTime < today)
               {
                  openNextDay();
                  return getRecord();
               }
                  // we've read through today, so just wait until tomorrow's
                  // data comes in - the user needs to call waitForData()
                  // to continue
               else
                  isOK = false;
            }
            else
            {
               isOK = false;
            }
         } // if (getmode == smart)
 
            // in dumb mode, the user needs to call openNextDay or
            // openCurrentFile to continue.
         else
         {
            isOK = false;
         }
      } // if (isOK)
      return isOK;
   }
 
   template <class FileStream, class FileData>
   void
   RTFileFrame<FileStream, FileData>::openNextDay()
   {
         // open a new file for another day, if any.
      currentTime += gnsstk::CommonTime::SEC_DAY;
      if (!endOfDataSet())
         openCurrentFile();
   }
 
   template <class FileStream, class FileData>
   std::list<FileData>
   RTFileFrame<FileStream, FileData>::getList() const
   {
      RTFileFrameIterator<FileStream, FileData> inputStream;
      std::list<FileData> toReturn;
      inputStream = begin();
      while (inputStream != end())
      {
         toReturn.push_back(data());
      }
      return toReturn;
   }
 
   template <class FileStream, class FileData>
   FileFilter<FileData>
   RTFileFrame<FileStream, FileData>::getFileFilter() const
   {
      RTFileFrameIterator<FileStream, FileData> inputStream;
      FileFilter<FileData> toReturn;
      inputStream = begin();
      while (inputStream != end())
      {
         toReturn.addData(data());
      }
      return toReturn;
   }
 
   template <class FileStream, class FileData>
   bool
   RTFileFrame<FileStream, FileData>::openCurrentFile()
   {
      isOK = false;
      currentFileName = fs.toString(currentTime);
      stat(currentFileName.c_str(), &fileInfo);
      lastPosition = 0;
 
      if(fileStream)
      {
         fileStream->close();
         delete fileStream;
         fileStream = NULL;
      }
 
      fileStream = new FileStream;
      fileStream->open(currentFileName.c_str(), std::ios::in);
      if (!fileStream->fail())
         isOK = true;
      return isOK;
   }
 
   template <class FileStream, class FileData>
   void
   RTFileFrame<FileStream, FileData>::closeCurrentFile()
   {
      if(fileStream)
      {
         fileStream->close();
         delete fileStream;
         fileStream = NULL;
      }
      isOK = false;
   }
 
} // namespace gnsstk
 
#endif  // GNSSTK_RTFILEFRAME_HPP