sffostream.h

Go to the documentation of this file.

// include guard
#ifndef TF_SFFOSTREAM_H_VERSION

#define TF_SFFOSTREAM_H_VERSION \
  "TF_SFFOSTREAM_H   V1.4"

#include<sffxx.h>
#include<iostream>
#include<new>

namespace sff {

namespace helper {

  class ostream_manager {
    public:
      ostream_manager(std::ostream& os, const bool& debug=false);
      void setfileheader(const FileHeader&);
      void settraceheader(const TraceHeader&);
      void setinfo(const INFO&);
      void setwid2(const WID2&);
      void setsrce(const SRCE&);
      void setfree(const FREE&);
      void setnormmode(const Enormmode&);
      void nextislast();
      void clearlast();
      TraceHeader traceheader() const;
      const FileHeader& fileheader() const;
      const Enormmode& normmode() const;
    protected:
      void flushheader();
      std::ostream& Mos;
    private:
      FileHeader Mfileheader;
      TraceHeader Mtraceheader;
      bool Mlast;
      bool Mfileheaderwritten;
      bool Mfilefreedefined;
      bool Mtraceinprogress;
      Enormmode Mnormmode;
    protected:
      bool Mdebug;
  }; // class ostream_manager

} // namespace helper

  template<class C>
  class SFFostream: public helper::ostream_manager {
    public:
      typedef C Tseries;
      typedef typename C::Tcoc Tcseries;
      typedef helper::ostream_manager Tbase;
      SFFostream(std::ostream& os, const bool& debug=false): 
        Tbase(os, debug), Mhasseries(false) { }
      ~SFFostream()
      { 
        if (!Mhasseries) throw
          Terror("ERROR (~SFFostream): no waveform!");
        this->nextislast();
        write();
      }
      void setseries(const Tcseries& series);
    private:
      void write();
      Tcseries Mseries;
      bool Mhasseries;
  }; // class SFFostream

  /*----------------------------------------------------------------------*/

  template<class C>
  inline
  void
  SFFostream<C>::write()
  {
    using std::cout;
    using std::endl;
    // flush file header (in case we have to write the first trace)
    this->flushheader();
    if (Mhasseries) 
    {
      Mos << OutputWaveform<Tseries>(Mseries, 
                                     this->traceheader(),
                                     this->normmode());
      Mhasseries=false;
      if (Mdebug) 
      { 
        cout << "DEBUG (SFFostream::write): trace written:" << endl; 
        cout << "      " << this->traceheader().wid2().line().substr(0,70) 
          << endl;
        cout << "      index range: " << Mseries.f() << " - "  
                                      << Mseries.l() << "; ";
        cout << "some values: " << Mseries(Mseries.f()) 
                        << ", " << Mseries(Mseries.f()+1)
                        << ", " << Mseries(Mseries.f()+2) 
                        << ", " << Mseries(Mseries.f()+3) 
                        << endl;
      }
    }
    if (Mdebug) { cout << "DEBUG (SFFostream::write): finished" << endl; }
  } // SFFostream<C>::write()

  /*----------------------------------------------------------------------*/

  template<class C>
  inline
  void
  SFFostream<C>::setseries(const Tcseries& series)
  {
    using std::cout;
    using std::endl;
    this->write();
    // using a deep copy here is the save way!
    Mseries=series.copyout();
    Mhasseries=true;
    if (Mdebug) 
    { 
      cout << "DEBUG (SFFostream::setseries) finished:" << endl; 
      cout << "      index range: " << Mseries.f() << " - "  
                                    << Mseries.l() << endl;
      cout << "      some values: " << Mseries(Mseries.f()) 
                     << ", " << Mseries(Mseries.f()+1)
                     << ", " << Mseries(Mseries.f()+2) 
                     << ", " << Mseries(Mseries.f()+3) 
                     << endl;
    }
  } // SFFostream<C>::setseries(const Tcseries& series)

  /*----------------------------------------------------------------------*/

  template<class C>
  SFFostream<C>& operator<<(SFFostream<C>& os, const typename C::Tcoc& c)
  { os.setseries(c); return(os); }

  template<class C>
  SFFostream<C>& operator<<(SFFostream<C>& os, const WID2& wid2)
  { os.setwid2(wid2); return(os); }

  template<class C>
  SFFostream<C>& operator<<(SFFostream<C>& os, const INFO& info)
  { os.setinfo(info); return(os); }

  template<class C>
  SFFostream<C>& operator<<(SFFostream<C>& os, const FREE& free)
  { os.setfree(free); return(os); }

  template<class C>
  SFFostream<C>& operator<<(SFFostream<C>& os, const SRCE& srce)
  { os.setsrce(srce); return(os); }

  template<class C>
  SFFostream<C>& operator<<(SFFostream<C>& os, const FileHeader& fh)
  { os.setfileheader(fh); return(os); }

  template<class C>
  SFFostream<C>& operator<<(SFFostream<C>& os, const TraceHeader& th)
  { os.settraceheader(th); return(os); }

} // namespace sff

#endif // TF_SFFOSTREAM_H_VERSION (includeguard)

/* ----- END OF sffostream.h ----- */