ParallelUnpacker.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2023 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// dspsr/Kernel/Classes/dsp/ParallelUnpacker.h
 
#ifndef __ParallelUnpacker_h
#define __ParallelUnpacker_h
 
#include "dsp/ParallelBitSeries.h"
#include "dsp/Unpacker.h"
#include "Registry.h"
 
namespace dsp {
 
  class ParallelInput;
 
  class ParallelUnpacker : public Transformation <ParallelBitSeries, TimeSeries>
  {
 
  public:
    
    ParallelUnpacker (const char* name);
 
    static ParallelUnpacker* create (const Observation* observation);
 
    ParallelUnpacker* clone() const;
 
    bool get_order_supported (TimeSeries::Order) const;
 
    void set_output_order (TimeSeries::Order);
 
    bool get_device_supported (Memory*) const;
 
    void set_device (Memory*);
 
 
    virtual bool matches (const Observation* observation) const = 0;
 
    virtual void match (const Observation* observation) = 0;
 
    virtual void match_resolution (ParallelInput*) { /* do nothing */ }
 
    virtual unsigned get_resolution () const { return 0; }
 
    void prepare () override;
 
    void reserve () override;
 
    uint64_t bytes_storage() const override;
 
    uint64_t bytes_scratch () const override;
    
    void set_buffering_policy (BufferingPolicy* policy);
 
    void set_cerr (std::ostream& os) const;
 
    typedef Registry::List<ParallelUnpacker> Register;
 
    static Register& get_register();
 
   protected:
 
    TimeSeries::Order output_order;
    
 
    virtual void unpack () = 0;
 
    void transformation ();
 
    std::vector< Reference::To<Unpacker> > unpackers;
 
  };
 
}
 
#endif // !defined(__ParallelUnpacker_h)