Input.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2002 - 2011 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// dspsr/Kernel/Classes/dsp/Input.h
 
#ifndef __Input_h
#define __Input_h
 
#include "dsp/Operation.h"
#include "dsp/Observation.h"
 
#include "MJD.h"
 
class ThreadContext;
 
namespace dsp {
 
  class BitSeries;
 
 
  class Input : public Operation
  {
 
    friend class IOManager;
 
  public:
    
    typedef BitSeries OutputType;
    
    Input (const char* name);
    
    virtual ~Input ();
 
    virtual const Input* get_origin () const { return this; }
 
    virtual void copy (const Input* input);
 
    void prepare ();
 
    void reserve ();
 
    void reserve (BitSeries*);
 
    virtual bool eod() const = 0;
 
    virtual void restart ();
 
 
    void load (BitSeries* data);
 
    virtual void set_output (BitSeries* data);
 
    virtual BitSeries* get_output();
 
    virtual bool has_output () const;
 
    virtual void seek (int64_t offset, int whence = 0);
 
    uint64_t tell () const { return load_sample; }
 
    virtual void seek (const MJD& mjd);
    
    virtual uint64_t get_block_size () const { return block_size; }
    virtual void set_block_size (uint64_t _size);
    
    virtual uint64_t get_overlap () const { return overlap; }
    virtual void set_overlap (uint64_t _overlap);
 
    virtual uint64_t get_stride () const { return get_block_size()-get_overlap(); }
 
    virtual uint64_t get_total_samples () const { return get_info()->get_ndat(); }
 
 
    void set_total_samples (uint64_t s) { get_info()->set_ndat(s); }
 
    operator const Observation* () const { return get_info(); }
 
    virtual Observation* get_info () { return info; }
 
    virtual const Observation* get_info () const { return info; }
 
    uint64_t get_load_sample () const { return load_sample; }
 
    uint64_t get_load_size () const { return load_size; }
 
    unsigned get_resolution () const { return resolution; }
 
    void set_resolution (unsigned res) { resolution = res; }
 
    void seek_seconds (double seconds, int whence = 0);
 
    double tell_seconds () const;
 
    void set_start_seconds (double seconds);
 
    void set_total_seconds (double seconds);
 
    void set_context (ThreadContext* context);
 
    bool has_context () const { return context != nullptr; }
 
    virtual std::string get_prefix () const;
 
  protected:
 
    virtual void set_eod (bool) = 0;
 
    Reference::To<BitSeries> output;
 
 
    virtual void load_data (BitSeries* data) = 0;
 
    virtual void operation ();
 
    virtual void mark_output ();
 
    Reference::To<Observation> info;
 
 
    unsigned resolution;
    
    uint64_t last_load_ndat;
 
    std::string real_source;
 
  private:
 
 
    uint64_t block_size;
        
 
    uint64_t overlap;
    
 
    unsigned resolution_offset;
 
    uint64_t load_sample;
 
    uint64_t load_size;
 
    uint64_t start_offset;
 
    void set_load_size ();
 
    ThreadContext* context;
  };
 
}
 
#endif // !defined(__Input_h)