FileFilter.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_FILEFILTER_HPP
#define GNSSTK_FILEFILTER_HPP
 
#include <functional>
#include <algorithm>
#include <iterator>
 
#include "FFData.hpp"
#include "FileSpec.hpp"
 
namespace gnsstk
{
 
 
   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();
 
         if (second != dataVec.end() )
            second++;
         else
            return *this;  // empty list
 
            // 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()
      {
         GNSSTK_ASSERT(!empty());
         return dataVec.front();
      }
 
      const FileData& front() const
      {
         GNSSTK_ASSERT(!empty());
         return dataVec.front();
      }
 
      FileData& back()
      {
         GNSSTK_ASSERT(!empty());
         return dataVec.back();
      }
 
      const FileData& back() const
      {
         GNSSTK_ASSERT(!empty());
         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 gnsstk
 
#endif // GNSSTK_FILEFILTER_HPP