dropcontainer.h

Go to the documentation of this file.

// include guard
#ifndef TF_DROPCONTAINER_H_VERSION

#define TF_DROPCONTAINER_H_VERSION \
  "TF_DROPCONTAINER_H   V1.0"

#include<string>
#include<tsxx/tsxx.h>
#include<tsxx/firfilters.h>

namespace ts {

  namespace drop {

    template<class T>
    class DropContainer {
      public:
        typedef T Tvalue;
        typedef DropContainer<Tvalue>* PDropContainer;
        typedef aff::Series<Tvalue> Tseries;
        DropContainer(): Moutput(0) { }
        virtual ~DropContainer()
        { if (Moutput != 0) { delete Moutput; } }
        virtual void initialize(const int& n);
        virtual void drop(const Tvalue& v)=0;
        virtual PDropContainer attach(const DropContainer& c)
        { 
          if (Moutput!=0) { Moutput->attach(c); }
          else { Moutput=c.clone(); }
          return this; 
        }
        virtual const typename Tseries::Tcoc& container() const
        { return(attached()->container()); }
        virtual int downsampling_factor() const
        { 
          if (Moutput!=0) { return(Moutput->downsampling_factor()); } 
          return 1;
        }
        virtual Tvalue gain() const
        { 
          if (Moutput!=0) { return(Moutput->gain()); } 
          return 1;
        }
      protected:
        virtual PDropContainer clone() const=0;
        virtual void initializenext(const int& n)=0;
        PDropContainer attached() const
        {
          TSXX_assert(Moutput != 0,
                      "DropContainer: not properly initialized!");
          return(Moutput);
        }
        PDropContainer Moutput;
    }; // class DropContainer

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

    template<class T>
    class SeriesDropContainer: public DropContainer<T> {
      public:
        typedef DropContainer<T> Tbase;
        typedef typename Tbase::Tvalue Tvalue;
        typedef DropContainer<Tvalue>* PDropContainer;
        typedef typename Tbase::Tseries Tseries;
        typedef aff::Tsubscript Tsubscript;
        SeriesDropContainer(): Ms(1), Mi(0) { }
        virtual ~SeriesDropContainer() { }
        virtual void drop(const Tvalue& v) 
        { 
          TSXX_assert(Mi <= Ms.l(),
                      "SeriesDropContainer: index out of bounds");
          Ms(Mi)=v; 
          ++Mi; 
        }
        virtual int downsampling_factor() const { return(1); }
        virtual Tvalue gain() const { return(1); }
        virtual PDropContainer attach(const Tbase& c)
        { TSXX_abort("SeriesDropContainer: "
                     "do not attach after initialization!"); }
      protected:
        virtual PDropContainer clone() const
        { 
          SeriesDropContainer<T>* retval(new SeriesDropContainer);
          retval->initializenext(Ms.size());
          return(retval);
        }
        virtual void initializenext(const int& n) 
        { Ms=Tseries(n); Mi=Ms.f(); }
        virtual const typename Tseries::Tcoc& container() const { return(Ms); }
      private:
        Tseries Ms;
        Tsubscript Mi;
    }; // class SeriesDropContainer

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

    template<class T>
    class DropDropContainer: public DropContainer<T> {
      public:
        typedef DropContainer<T> Tbase;
        typedef typename Tbase::Tvalue Tvalue;
        typedef DropContainer<Tvalue>* PDropContainer;
        DropDropContainer(const int& n): Mn(n), Mi(0) { }
        virtual ~DropDropContainer() { }
        virtual void drop(const Tvalue& v)
        {
          --Mi;
          if (Mi<1) 
          {
            Mi=Mn;
            Tbase::attached()->drop(v);
          }
        }
        virtual int downsampling_factor() const 
        { return(Mn*Tbase::downsampling_factor()); }
      protected:
        virtual PDropContainer clone() const
        { 
          DropDropContainer<T>* retval(new DropDropContainer(Mn)); 
          return(retval);
        }
        virtual void initializenext(const int& n)
        { Tbase::Moutput->initialize(n/Mn); Mi=0; }
      private:
        int Mn, Mi;
    }; // class DropDropContainer

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

    template<class T>
    class PassDropContainer: public DropContainer<T> {
      public:
        typedef DropContainer<T> Tbase;
        typedef typename Tbase::Tvalue Tvalue;
        typedef DropContainer<Tvalue>* PDropContainer;
        PassDropContainer() { }
        virtual ~PassDropContainer() { }
        virtual void drop(const Tvalue& v)
        { Tbase::attached()->drop(v); }
      protected:
        virtual PDropContainer clone() const
        { 
          PassDropContainer<T>* retval(new PassDropContainer); 
          return(retval);
        }
        virtual void initializenext(const int& n)
        { Tbase::Moutput->initialize(n); }
      private:
    }; // class PassDropContainer

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

    template<class T>
    class FIRDropContainer: public DropContainer<T> {
      public:
        typedef DropContainer<T> Tbase;
        typedef typename Tbase::Tvalue Tvalue;
        typedef DropContainer<Tvalue>* PDropContainer;
        typedef ts::fir::FIRfilter<Tvalue> Tfirfilter;
        FIRDropContainer(const std::string& name): 
          Mf(new Tfirfilter(name)), Mi(Mf->fir().delay) { }
        virtual ~FIRDropContainer() { delete Mf; }
        virtual void drop(const Tvalue& v);
      protected:
        virtual PDropContainer clone() const
        { 
          FIRDropContainer<T>* retval(new FIRDropContainer(Mf->fir().name)); 
          return(retval);
        }
        virtual void initializenext(const int& n)
        { 
          Tbase::Moutput->initialize(n/Mf->fir().decimation_factor); 
          Mf->clear();
          Mi=Mf->fir().delay;
        }
        virtual int downsampling_factor() const 
        { return(Mf->fir().decimation_factor*Tbase::downsampling_factor()); }
        virtual Tvalue gain() const 
        { return(Mf->fir().gain*Tbase::gain()); }
      private:
        Tfirfilter* Mf;
        int Mi;
    }; // class FIRDropContainer

    /*======================================================================*/

    template<class T>
      void DropContainer<T>::initialize(const int& n)
      {
        if (Moutput == 0)
        { Moutput=new SeriesDropContainer<T>; } 
        this->initializenext(n); 
      }

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

    template<class T>
      void FIRDropContainer<T>::drop(const Tvalue& v)
      {
        Mf->push(v);
        --Mi;
        if (Mi<1)
        {
          Mi=Mf->fir().decimation_factor; 
          Tbase::attached()->drop(Mf->pop());
        }
      }

  } // namespace drop

} // namespace ts

#endif // TF_DROPCONTAINER_H_VERSION (includeguard)

/* ----- END OF dropcontainer.h ----- */