filterbase.h

Go to the documentation of this file.

// include guard
#ifndef TF_FILTERBASE_H_VERSION

#define TF_FILTERBASE_H_VERSION \
  "TF_FILTERBASE_H   V1.1"

#include<list>
#include<string>
#include<tsxx/dttimeseries.h>
#include<tfxx/handle.h>
#include<tfxx/error.h>

namespace ts {

  namespace filter {

    typedef double Tvalue;

    typedef ts::TDtimeseries Ttimeseries;

    class BasicFilter {
      public:
        typedef double Tvalue;
        typedef ts::filter::Ttimeseries Ttimeseries;
        typedef Ttimeseries::Tseries Tseries;
        typedef Ttimeseries::Theader Theader;
        virtual ~BasicFilter();
        virtual Ttimeseries operator()(const Ttimeseries& s,
                                       const bool& debug=false) const =0;
        Ttimeseries operator()(const Tseries& s, const Tvalue& dt) const
        { return this->operator()(Ttimeseries(s, Theader(dt))); }
        template <class H>
        Ttimeseries operator()(const ts::TimeSeries<Tseries, H>& s) const
        { return this->operator()(Ttimeseries(s, Theader(s.header.dt))); }
      protected:
        BasicFilter();
    }; // class BasicFilter

    typedef tfxx::Handle<BasicFilter> Tfilterhandle;

    class FilterCollection: public std::list<Tfilterhandle> {
      public: 
        typedef ts::filter::Tfilterhandle Tfilterhandle;
        typedef Tfilterhandle::Tobject Tfilter;
        typedef std::list<Tfilterhandle> Tfilterlist;
        typedef Tfilterlist Tbase;
        typedef Ttimeseries::Tseries Tseries;
        typedef Ttimeseries::Theader Theader;
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
        Ttimeseries operator()(const Tseries& s, const Tvalue& dt) const
        { return this->operator()(Ttimeseries(s, Theader(dt))); }
        template <class H>
        Ttimeseries operator()(const ts::TimeSeries<Tseries, H>& s) const
        { return this->operator()(Ttimeseries(s, Theader(s.header.dt))); }
    }; // class FilterCollection

    class Noop: public BasicFilter {
      public:
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const { return s; }
    }; // class Noop

    class Exception: public tfxx::error::Exception {
      public:
        typedef tfxx::error::Exception Tbase;
        Exception(const char* message, 
                  const char* file,
                  const int& line,
                  const char* condition): 
          Tbase(message, file, line, condition) { }
        virtual void report() const;
    }; // class Exception

    class UnknownFilterException: public Exception {
      public: 
        typedef Exception Tbase;
        UnknownFilterException(const char* message, 
                               const char* file,
                               const int& line,
                               const std::string& filter):
          Tbase(message, file, line, "filter type is unknown"),
          Mfilter(filter) { }
        virtual ~UnknownFilterException() { }
        virtual void report() const;
      private:
        std::string Mfilter;
    }; // UnknownFilterException

  } // namespace filter

} // namespace ts

#define TSXX_UnknownFilterAbort(M, F) \
  throw( ts::filter::UnknownFilterException ( M , __FILE__, __LINE__, F )) 

#endif // TF_FILTERBASE_H_VERSION (includeguard)

/* ----- END OF filterbase.h ----- */