ParallelInput.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2023 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// dspsr/Kernel/Classes/dsp/ParallelInput.h
 
#ifndef __dsp_Kernel_Classes_ParallelInput_h
#define __dsp_Kernel_Classes_ParallelInput_h
 
#include "dsp/Operation.h"
#include "Registry.h"
#include "MJD.h"
 
namespace dsp {
 
  class ParallelBitSeries;
  class Observation;
  class Input;
 
  class ParallelInput : public Operation
  {
 
  public:
  
    typedef ParallelBitSeries OutputType;
 
    ParallelInput (const char* name);
    
    virtual ~ParallelInput ();
 
 
    static ParallelInput* create (const std::string& descriptor);
 
    const Input* at (unsigned index) const;
 
    Input* at (unsigned index);
 
 
    virtual bool matches (const std::string& descriptor) const = 0;
 
    virtual void open (const std::string& descriptor) = 0;
 
    void operation ();
    
    operator const Observation* () const { return get_info(); }
 
    virtual Observation* get_info ();
 
    virtual const Observation* get_info () const;
 
    virtual void set_output (ParallelBitSeries*);
 
    ParallelBitSeries* get_output ();
 
    virtual void prepare ();
 
    virtual void reserve ();
 
    virtual void reserve (ParallelBitSeries*);
 
    virtual bool eod() const;
 
    void restart ();
 
 
    virtual void load (ParallelBitSeries*);
 
    virtual void seek (int64_t offset, int whence = 0);
 
    uint64_t tell () const;
 
    virtual void seek (const MJD& mjd);
 
    double tell_seconds () const;
 
    void set_start_seconds (double seconds);
 
    void set_total_seconds (double seconds);
 
    virtual uint64_t get_block_size () const = 0;
    virtual void set_block_size (uint64_t _size) = 0;
 
    virtual uint64_t get_overlap () const = 0;
    virtual void set_overlap (uint64_t _overlap) = 0;
 
    virtual unsigned get_resolution () const = 0;
 
    uint64_t bytes_storage() const override;
 
    uint64_t bytes_scratch () const override;
 
    virtual void set_context (ThreadContext* _context) { context = _context; }
    bool has_context () const { return context != nullptr; }
    ThreadContext* get_context () { return context; }
 
    typedef Registry::List<ParallelInput> Register;
 
    static Register& get_register();
 
  protected:
 
    Reference::To<Observation> info;
 
    std::vector< Reference::To<Input> > inputs;
 
    Reference::To<ParallelBitSeries> output;
    
    ThreadContext* context {NULL};
  };
 
}
 
#endif // !defined(__dsp_Kernel_Classes_ParallelInput_h)