DataSeries.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2004 by Haydon Knight
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
#ifndef __DataSeries_h
#define __DataSeries_h
 
#include "dsp/Observation.h"
 
 
namespace dsp {
 
  class Memory;
 
  /* The DataSeries class contains n-bit data arranged as a
     function of frequency, polarization, time, and dimension, ie.
 
     f0p0t0d0...f0p0t0dD,f0p0t1d0...f0p0t1dD...f0p0tTd0...f0p0tTdD, 
     f0p1t0d0...f0p1t0dD,f0p1t1d0...f0p1t1dD...f0p1tTd0...f0p1tTdD, 
     ...
     f0pPt0d0...f0pPt0dD,f0pPt1d0...f0pPt1dD...f0pPtTd0...f0pPtTdD, 
     f1p0t0d0...f1p0t0dD,f1p0t1d0...f1p0t1dD...f1p0tTd0...f1p0tTdD, 
     ...
     fFpPt0d0...fFpPt0dD,fFpPt1d0...fFpPt1dD...fFpPtTd0...fFpPtTdD
  */
  class DataSeries : public Observation {
    
  public:
 
    static int instantiation_count;
    static int64_t memory_used;
 
    DataSeries ();
 
    DataSeries(const DataSeries& ds);
 
    void initi();
 
    virtual DataSeries* clone() const = 0;
 
    virtual DataSeries* null_clone() const = 0;
 
    virtual DataSeries& swap_data(DataSeries& ds);
 
    virtual ~DataSeries();
 
    virtual DataSeries& operator = (const DataSeries& copy);
 
    void copy (const Observation* ds);
 
    virtual void copy (const DataSeries* ds)
    { operator=( *ds ); }
 
    void set_ndat (uint64_t);
 
    void set_ndim (unsigned);
 
    void set_npol (unsigned);
 
    void set_nchan (unsigned);
 
    uint64_t get_ndat_allocated();
 
    bool reshape_required () { return shape_changed; };
 
    virtual void resize (uint64_t nsamples);
 
    virtual void resize (uint64_t nsamples, unsigned char*& old_buffer);
 
    void reshape ();
 
    void reshape (unsigned npol, unsigned ndim);
 
    virtual void zero ();
 
    virtual unsigned char* get_udatptr (unsigned ichan=0,unsigned ipol=0);
 
    virtual const unsigned char* get_udatptr (unsigned ichan=0,unsigned ipol=0) const;
 
    virtual uint64_t get_subsize(){ return subsize; }
 
    virtual void internal_match (const DataSeries*);
 
    virtual void copy_configuration (const Observation* copy);
 
    unsigned char* internal_get_buffer() { return buffer; }
    const unsigned char* internal_get_buffer() const { return buffer; }
 
    uint64_t internal_get_size() const { return size; }
 
    uint64_t internal_get_subsize() const { return subsize; }
 
    virtual void set_memory (Memory*);
    const Memory* get_memory () const;
 
  protected:
    
    virtual unsigned char* get_data();
    virtual const unsigned char* get_data() const;
 
    unsigned char* buffer = nullptr;
 
    uint64_t size = 0;
 
    uint64_t subsize = 0;
 
    bool shape_changed = false;
 
    Reference::To<Memory> memory;
 
  };
 
}  
 
#endif