FileFilterFrame.hpp

Go to the documentation of this file.

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



#ifndef GPSTK_FILEFILTERFRAME_HPP
#define GPSTK_FILEFILTERFRAME_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 "FileSpec.hpp"
#include "FileFilter.hpp"
#include "FileHunter.hpp"
#include "FileUtils.hpp"

namespace gpstk
{

   template <class FileStream, class FileData>
   class FileFilterFrame : public FileFilter<FileData>
   {
   public:
      FileFilterFrame(const gpstk::DayTime& start = 
                         gpstk::DayTime::BEGINNING_OF_TIME,
                      const gpstk::DayTime& end = 
                         gpstk::DayTime::END_OF_TIME)
         throw(gpstk::Exception);

      FileFilterFrame(const std::vector<std::string>& fileList,
                      const gpstk::DayTime& start = 
                         gpstk::DayTime::BEGINNING_OF_TIME,
                      const gpstk::DayTime& end = 
                         gpstk::DayTime::END_OF_TIME)
         throw(gpstk::Exception);

      FileFilterFrame(const std::string& filename, 
                      const gpstk::DayTime& start = 
                         gpstk::DayTime::BEGINNING_OF_TIME,
                      const gpstk::DayTime& end = 
                         gpstk::DayTime::END_OF_TIME)
         throw(gpstk::Exception);

      FileFilterFrame(const FileSpec& spec, 
                      const gpstk::DayTime& start = 
                         gpstk::DayTime::BEGINNING_OF_TIME,
                      const gpstk::DayTime& end = 
                         gpstk::DayTime::END_OF_TIME,
                      const std::vector<FileHunter::FilterPair>& filter = 
                      std::vector<FileHunter::FilterPair>())
         throw(gpstk::Exception);

      FileFilterFrame& 
      newSource(const FileSpec& filespec, 
                const gpstk::DayTime& start = 
                   gpstk::DayTime::BEGINNING_OF_TIME,
                const gpstk::DayTime& end = 
                   gpstk::DayTime::END_OF_TIME,
                const std::vector<FileHunter::FilterPair>& filter = 
                   std::vector<FileHunter::FilterPair>())
         throw(gpstk::Exception);

      FileFilterFrame& 
      newSource(const std::string& filename, 
                const gpstk::DayTime& start = 
                   gpstk::DayTime::BEGINNING_OF_TIME,
                const gpstk::DayTime& end = 
                   gpstk::DayTime::END_OF_TIME)
         throw(gpstk::Exception);

      FileFilterFrame&
      newSource(const std::vector<std::string>& fileList,
                const gpstk::DayTime& start = 
                   gpstk::DayTime::BEGINNING_OF_TIME,
                const gpstk::DayTime& end = 
                   gpstk::DayTime::END_OF_TIME)
         throw(gpstk::Exception);

      virtual ~FileFilterFrame() {}

      bool writeFile(const std::string& outputFile,
                     const bool append = false) const
         throw(gpstk::Exception);

      bool writeFile(FileStream& stream) const
         throw(gpstk::Exception);

   protected:
      void init(const std::vector<FileHunter::FilterPair>& filter= 
                std::vector<FileHunter::FilterPair>()) 
         throw(gpstk::Exception);


   protected:   
      FileSpec fs;
      gpstk::DayTime startTime, endTime;

   };


   template <class FileStream, class FileData>
   FileFilterFrame<FileStream,FileData> :: 
   FileFilterFrame(const gpstk::DayTime& start,
                   const gpstk::DayTime& end)
      throw(gpstk::Exception)
         : startTime(start), endTime(end)
   {}

   template <class FileStream, class FileData>
   FileFilterFrame<FileStream,FileData> :: 
   FileFilterFrame(const std::vector<std::string>& fileList,
                   const gpstk::DayTime& start,
                   const gpstk::DayTime& end)
      throw(gpstk::Exception)
         : startTime(start), endTime(end)
   {
      typename std::vector<std::string>::const_iterator itr;
      for (itr = fileList.begin(); itr != fileList.end(); itr++)
      {
         fs.newSpec(*itr);
         init();
      }
   }

   template <class FileStream, class FileData>
   FileFilterFrame<FileStream,FileData> :: 
   FileFilterFrame(const std::string& filename, 
                   const gpstk::DayTime& start,
                   const gpstk::DayTime& end)
      throw(gpstk::Exception)
         : fs(filename), startTime(start), endTime(end)
   {
      init();
   }

   template <class FileStream, class FileData>
   FileFilterFrame<FileStream,FileData> :: 
   FileFilterFrame(const FileSpec& spec, 
                   const gpstk::DayTime& start,
                   const gpstk::DayTime& end,
                   const std::vector<FileHunter::FilterPair>& filter)
      throw(gpstk::Exception)
         : fs(spec), startTime(start), endTime(end)
   {
      init(filter);
   }

   template <class FileStream, class FileData>
   FileFilterFrame<FileStream, FileData>& 
   FileFilterFrame<FileStream,FileData> :: 
   newSource(const FileSpec& filespec, 
             const gpstk::DayTime& start,
             const gpstk::DayTime& end,
             const std::vector<FileHunter::FilterPair>& filter)
      throw(gpstk::Exception)
   {
      startTime = start;
      endTime = end;

      fs = filespec;
      init(filter);
      return *this;
   }

   template <class FileStream, class FileData>
   FileFilterFrame<FileStream, FileData>& 
   FileFilterFrame<FileStream,FileData> :: 
   newSource(const std::string& filename, 
             const gpstk::DayTime& start,
             const gpstk::DayTime& end)
      throw(gpstk::Exception)
   {
      startTime = start;
      endTime = end;
   
      fs.newSpec(filename);
      init();
      return *this;
   }

   template <class FileStream, class FileData>
   FileFilterFrame<FileStream, FileData>& 
   FileFilterFrame<FileStream,FileData> :: 
   newSource(const std::vector<std::string>& fileList, 
             const gpstk::DayTime& start,
             const gpstk::DayTime& end)
      throw(gpstk::Exception)
   {
      startTime = start;
      endTime = end;
   
      typename std::vector<std::string>::const_iterator itr;
      for (itr = fileList.begin(); itr != fileList.end(); itr++)
      {
         fs.newSpec(*itr);
         init();
      }
      return *this;
   }

   template <class FileStream, class FileData>
   void
   FileFilterFrame<FileStream,FileData> :: 
   init(const std::vector<FileHunter::FilterPair>& filter)
      throw(gpstk::Exception)
   {
         // find the files
      FileHunter fh(fs);
   
      typename std::vector<FileHunter::FilterPair>::const_iterator itr = 
         filter.begin();
      while (itr != filter.end())
      {
         fh.setFilter((*itr).first, (*itr).second);
         itr++;
      }

      std::vector<std::string> listOfFiles = 
         fh.find(startTime, endTime, FileSpec::ascending);

         // for each file, read it into the filter
      typename std::vector<std::string>::iterator i;
      for(i = listOfFiles.begin(); i != listOfFiles.end(); i++)
      {
         FileStream s((*i).c_str());

         if (s.good())
         {
            s.exceptions(std::ios::failbit);
         
            FileData data;
         
            while (s >> data)
            {
               addData(data);
            }
         }
      }
   }

   template <class FileStream, class FileData>
   bool FileFilterFrame<FileStream,FileData> :: 
   writeFile(const std::string& str,
             const bool append) const
      throw(gpstk::Exception)
   {
      if (!this->dataVec.empty())
      {
            // make the directory (if needed)
         std::string::size_type pos = str.rfind('/');
         if (pos != std::string::npos)
            gpstk::FileUtils::makeDir(str.substr(0,pos).c_str(), 0755);      

         std::ios::openmode mode = std::ios::out;
         if (append)
            mode |= (std::ios::app|std::ios::ate);
      
         FileStream stream(str.c_str(), mode);
         return writeFile(stream);
      }

      return true;
   }

   template <class FileStream, class FileData>
   bool FileFilterFrame<FileStream,FileData> :: 
   writeFile(FileStream& stream)
      const throw(gpstk::Exception)
   {
      if (!this->dataVec.empty())
      {
         stream.exceptions(std::ios::failbit);      
      
         typename std::list<FileData>::const_iterator index;
         for(index = this->dataVec.begin(); index != this->dataVec.end(); index++)
            (*index).putRecord(stream);
      }

      return true;
   }

}  // namespace gpstk

#endif // GPSTK_FILEFILTERFRAME_HPP

---