FileFilter.hpp

Go to the documentation of this file.

#pragma ident "$Id: FileFilter.hpp 2535 2011-03-25 15:58:06Z ccutlip $"



#ifndef GPSTK_FILEFILTER_HPP
#define GPSTK_FILEFILTER_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 <functional>
#include <algorithm>
#include <iterator>

#include "FFData.hpp"
#include "FileSpec.hpp"

namespace gpstk
{

   template<class FileData>
   class FileFilter
   {
   public:
      FileFilter(void);

      virtual ~FileFilter();

      FileFilter& addData(const FileData& ffd);

      FileFilter& addData(const std::list<FileData>& datavec);

      template <class Compare>
      FileFilter& sort(Compare comp)
     {
         // FIX: this someday...
         // this is a total hack until Solaris gets their act together and
         // gets list::sort() working again
         // all the code below can be replaced (someday) by this one line:
         //      dataVec.sort(comp);

         // make a vector of pointer to list iterator objects...
      std::vector<lItrType> data(dataVec.size());
      lItrType itr = dataVec.begin();
      typename std::vector<lItrType>::size_type i = 0;
      while (itr != dataVec.end())
      {
         data[i] = itr;
         i++;
         itr++;
      }
      
         // use SortAdapter to use comp with the pointer vector
         // then sort the vector
      SortAdapter<Compare> sa(comp);
      std::stable_sort(data.begin(), data.end(), sa);
      
         // make a new list of the data in the right order, then copy that
         // over dataVec.
      lType fdlist;
      for (i = 0; i < data.size(); i++)
      {
         fdlist.push_back(*data[i]);
      }
      dataVec = fdlist;
      
/*
         // move the items into the correct order with splice.
         // splice does nothing if (itr == data[i]) || (itr == ++data[i])
         // so the data is inserted backwards to avoid this...
      i = data.size();
      while (i != 0)
      {
         itr = dataVec.begin();
         --i;
         dataVec.splice(itr, dataVec, data[i]);
      }
*/            
      return *this;
   }


      FileFilter& merge(const FileFilter& right);

      template <class Compare>
      FileFilter& merge(const FileFilter& right, Compare bp)
         { merge(right); sort(bp); return *this; }

      template <class BinaryPredicate>
      FileFilter& unique(BinaryPredicate bp)
   {
         //  FIX: unique is broken or doesnt like my syntax
         //  so i wrote my own version of it
//      list<FileData>::iterator itr = 
//         unique(dataVec.begin(), dataVec.end(), bp);
      filtered = 0;
      
      typename std::list<FileData>::iterator first = dataVec.begin();
      typename std::list<FileData>::iterator second= dataVec.begin();
      second++;
      
         // keep only the first of many unique values
      while (second != dataVec.end())
      {
         if ( bp(*first, *second))
         {
            second = dataVec.erase(second);
            filtered++;
         }
         else
         {
            first++;
            second++;
         }
      }
      
      return *this;
   }

      template <class Predicate>
      FileFilter& filter(Predicate up)
   {
         // delete all values for which up() is true
      filtered = 0;
      
      typename std::list<FileData>::iterator itr = dataVec.begin();
      
      while (itr != dataVec.end())
      {
         if (up(*itr))
         {
            itr = dataVec.erase(itr);
            filtered++;
         }
         else
            itr++;
      }
      
      return *this;
   }

      template <class Operation>
      FileFilter& touch(Operation& op)
   {
      filtered = 0;
      
      typename std::list<FileData>::iterator itr = dataVec.begin();
      
      while (itr != dataVec.end())
      {
         if (op(*itr))
            filtered++;
         itr++;
      }
      
      return *this;
   }

      template <class Operation>
      FileFilter& touch(const Operation& op)
         { Operation o(op); return touch(o); }

      template <class BinaryPredicate>
      std::pair< std::list<FileData>, std::list<FileData> > 
      diff(const FileFilter<FileData>& r, BinaryPredicate p) const
   {
      std::pair< std::list<FileData>, std::list<FileData> > toReturn;
      
      std::set_difference(dataVec.begin(), dataVec.end(),
                          r.dataVec.begin(), r.dataVec.end(),
                          std::inserter(toReturn.first, 
                                        toReturn.first.begin()),
                          p);
      
      std::set_difference(r.dataVec.begin(), r.dataVec.end(),
                          dataVec.begin(), dataVec.end(),
                          std::inserter(toReturn.second, 
                                        toReturn.second.begin()),
                          p);
      
      return toReturn;
   }

      template <class Predicate>
      std::list<FileData> findAll(Predicate p) const
   {
      std::list<FileData> toReturn;
      typename std::list<FileData>::const_iterator itr = dataVec.begin();
      
      while (itr != dataVec.end())
      {
         if (p(*itr))
            toReturn.push_back((*itr));
         itr++;
      }
      
      return toReturn;
      
   }

      int getFiltered() const {return filtered;}

      std::list<FileData>& getData(void) {return dataVec;}

      std::list<FileData> getData(void) const {return dataVec;}

      typename std::list<FileData>::size_type getDataCount(void) const 
         { return dataVec.size(); }

      typename std::list<FileData>::const_iterator begin() const
         { return dataVec.begin(); }

      typename std::list<FileData>::const_iterator end() const
         { return dataVec.end(); }

      typename std::list<FileData>::iterator begin() 
         { return dataVec.begin(); }

      typename std::list<FileData>::iterator end() 
         { return dataVec.end(); }

      bool empty() const
         { return dataVec.empty(); }

      void clear()
         { dataVec.clear(); }

      typename std::list<FileData>::size_type size()
         { return dataVec.size(); }

      FileData& front()
         { return dataVec.front(); }

      const FileData& front() const
         { return dataVec.front(); }

      FileData& back()
         { return dataVec.back(); }

      const FileData& back() const
         { return dataVec.back(); }

   protected:
      typedef std::list<FileData> lType;
      lType dataVec;
      typedef typename std::list<FileData>::iterator lItrType;

      template<class Compare>
      class SortAdapter  : 
         public std::binary_function<lItrType, lItrType, bool>
      {
      public:
         SortAdapter(Compare& c)
               : comp(c)
            {}

         bool operator()(const lItrType l,
                         const lItrType r) const
            {
               return comp(*l, *r);
            }
      private:
         Compare comp;
      };

      int filtered;
   };


      template<class FileData>
   FileFilter<FileData> :: FileFilter(void)
         : filtered(0)
   {}

   template<class FileData>
   FileFilter<FileData> :: ~FileFilter()
   {
   }

   template<class FileData>
   FileFilter<FileData>& FileFilter<FileData> :: 
   addData(const FileData& ffd)
   {
      dataVec.push_back(ffd);
      return *this;
   }

   template <class FileData>
   FileFilter<FileData>& FileFilter<FileData> :: 
   addData(const std::list<FileData>& datavec)
   {
      std::copy(datavec.begin(), datavec.end(),
                std::inserter(dataVec, dataVec.begin()));
      return *this;
   }
   
   template <class FileData>
   FileFilter<FileData>&
   FileFilter<FileData> ::
   merge(const FileFilter<FileData>& right)
   {
         // cast out const to use the non-const version of getData()
      FileFilter<FileData>& r = (FileFilter<FileData>&)(right);
      
         // copy rightData into *this
      std::list<FileData>& rightData = r.getData();
      std::copy(rightData.begin(), rightData.end(),
                std::inserter(dataVec, dataVec.begin()));
      
      return *this;
   }

} // namespace gpstk

#endif // GPSTK_FILEFILTER_HPP

---