rtfileframe.hpp

gps源代码

      std::list<FileData> getList() const;

         /// this traverses the RTFileFrame from begin() to end(), adding
         /// each item to a FileFilter that gets returned. Using this will
         /// change the file position, so getRecord and any iterators
         /// will not be the same after this call.
      FileFilter<FileData> getFileFilter() const;

         /// returns the name of the current file begin used
      std::string getCurrentFile() const {return currentFileName;}

         /// returns the current time used for finding files
      gpstk::DayTime getCurrentTime() const {return currentTime;}

         /// let the iterator see this class's insides
      friend class RTFileFrameIterator<FileStream, FileData>;

         /// reopens the file \a currentFileName
      bool openCurrentFile();

         /// close the file \a currentFileName
      void closeCurrentFile();

   protected:
         /// the internal file stream for the internal iterator
      FileStream* fileStream;

      FileData lastData;
         /// the last get position from the file
      std::streampos lastPosition;
         /// the last file to be read
      std::string currentFileName;
         /// the file spec for determining file names
      gpstk::FileSpec fs;
      
      gpstk::DayTime startTime, ///< start time for file searching
         currentTime,            ///< time last used for finding a file
         endTime;                ///< end time for file searching
         /// the FileReadingMode for the reader
      FileReadingMode readMode;
         /// the GetRecordMode for the reader
      GetRecordMode getMode;
         /// keeps track of the last modify date for the last file read
      struct stat fileInfo;
         /// isOK is only false when the user needs to take action
         /// to continue reading - by calling waitForData(),
         /// openNextDay(), or openCurrentFile()
      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; 
   }

         /// Allows changing of the GetRecordMode
   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