RTFileFrame.hpp

Go to the documentation of this file.

#pragma ident "$Id: RTFileFrame.hpp 70 2006-08-01 18:36:21Z ehagen $"



#ifndef GPSTK_RTFILEFRAME_HPP
#define GPSTK_RTFILEFRAME_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
//  
//  Copyright 2004, The University of Texas at Austin
//
//============================================================================

//============================================================================
//
//This software 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 <sys/types.h>
#include <sys/stat.h>
#include <iterator>
#include "FileSpec.hpp"
#include "FileFilter.hpp"

namespace gpstk
{

   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(gpstk::RTFileFrame<FileStream, FileData>& r)
            : rtff(&r)
         { rtff->getRecord(); }

      gpstk::RTFileFrame<FileStream, FileData>* rtff;
   };

   template <class FileStream, class FileData>
   class RTFileFrame : public RTFileFrameHelper
   {
   public:
      RTFileFrame(const gpstk::FileSpec& fnFormat,
                  const gpstk::DayTime& beginning = gpstk::DayTime(),
                  const gpstk::DayTime& ending = gpstk::DayTime::END_OF_TIME, 
                  const FileReadingMode frm = AppendedData,
                  const GetRecordMode grm = Dumb)
         throw(gpstk::Exception);
      
      ~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;}

      gpstk::DayTime getCurrentTime() const {return currentTime;}

      friend class RTFileFrameIterator<FileStream, FileData>;

      bool openCurrentFile();

      void closeCurrentFile();

   protected:
      FileStream* fileStream;

      FileData lastData;
      std::streampos lastPosition;
      std::string currentFileName;
      gpstk::FileSpec fs;
      
      gpstk::DayTime startTime, 
         currentTime,            
         endTime;                

      FileReadingMode readMode;
      GetRecordMode getMode;
      struct stat fileInfo;
      bool isOK;
   };


   template <class FileStream, class FileData>
   RTFileFrame<FileStream, FileData>::
   RTFileFrame<FileStream, FileData>(const gpstk::FileSpec& fnFormat,
                                     const gpstk::DayTime& beginning,
                                     const gpstk::DayTime& ending, 
                                     const RTFileFrameHelper::FileReadingMode frm,
                                     const RTFileFrameHelper::GetRecordMode grm)
      throw(gpstk::Exception)
         : fileStream(NULL), fs(fnFormat), startTime(beginning), 
           currentTime(beginning), endTime(ending), readMode(frm), getMode(grm)
   {
         // zero out seconds
      startTime.setMJDdate(floor(startTime.MJDdate()));
      endTime.setMJDdate(floor(endTime.MJDdate()));
      currentTime.setMJDdate(floor(currentTime.MJDdate()));

         // 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?
               gpstk::DayTime 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 += gpstk::DayTime::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 gpstk

#endif  // GPSTK_RTFILEFRAME_HPP

---