frameutils/framedir.hh

/* -*- mode: c++; c-basic-offset: 4; -*- */
#ifndef FRAMEDIR_HH
#define FRAMEDIR_HH

//
// Frame finder class.
//
#include <map>
#include <iosfwd>
#include <iterator>
#include <string>
#include "PConfig.h"
#include "Time.hh"
#include "Interval.hh"
#include "fferrors.hh"

   struct ffData {
   public:
     typedef Time::ulong_t gps_t;

     typedef unsigned long count_t;
   
     ffData(void);
   
      ffData(const char* File, const Time& time, 
            Interval Dt=Interval(1.0), bool DataOK=true);
   
      ffData(const char* Prefix, const char* Suffix, const Time& time, 
            Interval Dt=Interval(1.0));
            
      Interval getDt(void) const;
   
      const char* getPrefix(void) const;
   
      const char* getSuffix(void) const;
          
      std::string getFile(count_t N = 0) const;

      bool advance(int N);
      
      Time getStartTime(void) const;
   
      Time getEndTime(void) const;
   
      bool isFollowed(void) const;
   
      bool isValid(void) const;
   
      gps_t getStartGPS(void) const;
   
      gps_t getEndGPS(void) const;
   
   protected:
      std::string mFilePrefix;
   
      std::string mFileSuffix;
      
      Time mStartGPS;
      
      Interval mDt;
   
      bool mNamingOK;
      
      bool mDataOK;
   };

   inline 
   ffData::ffData(const char* File, const Time& time,  
                 Interval Dt, bool DataOK)
   : mFilePrefix(File), mStartGPS(time), mDt(Dt), mNamingOK(false), 
   mDataOK(DataOK)
   {}

   inline 
   ffData::ffData(const char* Prefix, const char* Suffix, const Time& time, 
            Interval Dt)
   : mFilePrefix(Prefix), mFileSuffix(Suffix), mStartGPS(time), 
   mDt(Dt), mNamingOK(true), mDataOK(true) 
   {}
            
   inline  
   ffData::ffData(void) 
   : mNamingOK(false), mDataOK(false)
   {}

   inline Interval 
   ffData::getDt(void) const {
      return mDt;
   }

   inline const char*
   ffData::getPrefix(void) const {
      return mFilePrefix.c_str(); 
   }
   
   inline const char* 
   ffData::getSuffix(void) const {
      return mFileSuffix.c_str(); 
   }

   inline bool 
   ffData::isFollowed(void) const {
      return mNamingOK;
   }

   inline bool
   ffData::advance (int N)
   {
      if (!isFollowed()) {
         return false;
      }
      else {
         mStartGPS += mDt * double(N);
         return true;
      }
   }
   
   inline bool 
   ffData::isValid(void) const {
      return mDataOK;
   }
   
   inline Time 
   ffData::getStartTime(void) const {
      return mStartGPS;
   }

   inline Time 
   ffData::getEndTime(void) const {
      return mStartGPS + mDt;
   }

   inline ffData::gps_t
   ffData::getStartGPS(void) const {
      return mStartGPS.getS();
   }

   inline ffData::gps_t
   ffData::getEndGPS(void) const {
      return getEndTime().getS();
   }

   struct ffDataSeries : public ffData {
   public:
   
      ffDataSeries(void) : mNFiles (0) {}
   
      ffDataSeries(const char* File, const Time& time, 
             Interval Dt=Interval(1.0), bool DataOK=true)
      : ffData (File, time, Dt), mNFiles (1) 
      {}
      
      ffDataSeries(const char* Prefix, const char* Suffix,
             const Time& time, Interval Dt=Interval(1.0), count_t N = 1)
      : ffData (Prefix, Suffix, time, Dt), mNFiles (N) 
      {}
         
      ffDataSeries(const ffData& data) : ffData (data), mNFiles (1) {}
   
      bool joinable (const ffDataSeries& series) const;
      
      
      bool join (const ffDataSeries& series);
      
      bool join (const char* Prefix, const char* Suffix, 
            const Time& time, Interval Dt);
      
      Time getEndTime(void) const {
         return mStartGPS + mDt * double(mNFiles); }

      gps_t getEndGPS(void) const {
          return getEndTime().getS(); }
     
      Time getTime (count_t n) const {
         return mStartGPS + mDt * double(n); }
      
      gps_t getGPS (count_t n) const {
         return getTime(n).getS(); }
      
      Interval getLength(void) const {
         return mDt * double(mNFiles); }
         
      count_t getNFiles(void) const {
         return mNFiles; }
   
      void setNFiles(count_t N) {
         mNFiles = N; }
   
   private:     
      count_t mNFiles;   
   };


#ifdef __GNU_STDC_OLD
namespace std {
template <class _Category, class _Tp, class _Distance = ptrdiff_t,
          class _Pointer = _Tp*, class _Reference = _Tp&>
struct iterator {
  typedef _Category  iterator_category;
  typedef _Tp        value_type;
  typedef _Distance  difference_type;
  typedef _Pointer   pointer;
  typedef _Reference reference;
};
}
#endif
   
   struct ffDataConstIter : public std::iterator 
   <std::bidirectional_iterator_tag, ffData, int, const ffData*, 
    const ffData&> {
   public:
      typedef ffData::gps_t gps_t;

      typedef ffData::count_t count_t;

      typedef std::map<gps_t, ffDataSeries> dmap_t;  

      typedef dmap_t::const_iterator dmap_iterator;

      ffDataConstIter () : mList(0), mNFiles (0) {
      }
      ffDataConstIter (const dmap_t& List, const dmap_iterator& Iter,
            count_t Index) : mList(&List), mIndex (Iter),
            mNFiles (Index) {
         set();
      }
      bool operator== (const ffDataConstIter& i) const {
         return ((mList == i.mList) && (mNFiles == i.mNFiles) &&
          (mIndex == i.mIndex)); }
      bool operator!= (const ffDataConstIter& i) const {
         return !(*this == i); }
   
      ffDataConstIter& operator++ () {
         add (1); 
         return *this; }
      ffDataConstIter operator++ (int) {
         ffDataConstIter i = *this; add (1); 
         return i; }
      ffDataConstIter& operator-- () {
         add (-1); 
         return *this; }
      ffDataConstIter operator-- (int) {
         ffDataConstIter i = *this; add (-1); 
         return i; }
      ffDataConstIter operator+ (int delta) const {
         ffDataConstIter i = *this; i.add (delta);
         return i; }
      ffDataConstIter operator- (int delta) const {
         ffDataConstIter i = *this; i.add (-delta);
         return i; }
      ffDataConstIter& operator+= (int delta) {
         add (delta);
         return *this; }
      ffDataConstIter& operator-= (int delta) {
         add (-delta); 
         return *this; }
      reference operator*() const {
         return mData; }
      pointer operator->() const {
         return &mData; }
   protected:
      void set (void);
      void add (int delta);
   private:
      ffData mData;
      const dmap_t* mList;
     dmap_iterator mIndex;
      count_t mNFiles;
   };


   class FrameDir {
   
   public:
     typedef Time::ulong_t gps_t;

     typedef std::map<gps_t, ffDataSeries> dmap_t;
   
     typedef ffDataConstIter file_iterator;
   
      typedef dmap_t::const_iterator series_iterator;
      
   public:
      virtual ~FrameDir(void);
   
      FrameDir();
   
      explicit FrameDir(const char* dir, bool delayed = false);
   
   //------------------------------------  Accessors
      file_iterator find(const Time& t) const throw(NoData);
   
      file_iterator getStart(gps_t time) const;
   
      file_iterator getLast(gps_t time) const;
   
      int getDebug(void) const;
   
      file_iterator begin(void) const;
   
      file_iterator end(void) const;
   
      series_iterator beginSeries(void) const;
   
      series_iterator endSeries(void) const;
   
      int sizeSeries() const;

      int size() const;

      bool empty() const {
         return mList.empty(); }
   
   //------------------------------------  Mutators
   
      void add(const char* dir, bool delayed = false);
   
      void addFile(const char* File, unsigned int Cont = 0) throw(BadFile);
   
      void clear(void);
   
      void erase(gps_t time);
      
      void setDebug(int Level);

      bool read (const char* File);

     bool write (const char* File, bool Longlist = false,
                 gps_t Start = 0, gps_t Stop = 0, bool SupHead = false);

     bool write (std::ostream& Os, bool Longlist = false,
                 gps_t Start = 0, gps_t Stop = 0, bool SupHead = false);

      std::ostream& operator<< (std::ostream& Os);
      
      static bool parseName (const char* File, 
                             gps_t& time, gps_t& tlen,
                             char* pre = 0, char* post = 0);
   
   private:
      enum CheckLevel {none, gapsOnly, allData};
   
      void checkData(CheckLevel lvl=gapsOnly);
      void checkData(CheckLevel lvl=gapsOnly) const;
   
      void join();
      
      ffData getFileData(const char* File) throw(BadFile);
   
   private:
      int    mDebug;
      mutable bool   mDirty;
   
      dmap_t mList;

      dmap_t::iterator last_insert;
   };

   inline int 
   FrameDir::getDebug(void) const {
      return mDebug;
   }

   inline void
   FrameDir::setDebug(int Level) {
      mDebug = Level;
   }

#endif   // FRAMEDIR_HH

---