BitSeries.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2002 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
#ifndef __BitSeries_h
#define __BitSeries_h
 
#include <memory>
 
#include "dsp/Observation.h"
#include "dsp/Memory.h"
 
namespace dsp {
  
  class Input;
 
 
  class BitSeries : public Observation {
 
    friend class Input;
 
  public:
    BitSeries ();
 
    virtual ~BitSeries ();
 
    virtual void resize (int64_t nsamples);
    
    virtual BitSeries& operator = (const BitSeries& data);
 
    void copy (const Observation*);
 
    virtual void copy (const BitSeries* bs)
    { operator=( *bs ); }
 
    BitSeries& operator = (const Observation& obs)
    { Observation::operator= (obs); return *this; }
 
    virtual unsigned char* get_rawptr () { return data; }
 
    virtual const unsigned char* get_rawptr () const { return data; }
 
    virtual void zero ();
 
    unsigned get_request_offset () const { return request_offset; }
 
    uint64_t get_request_ndat () const { return request_ndat; }
 
    virtual unsigned char* get_datptr (uint64_t sample = 0);
 
    virtual const unsigned char* get_datptr (uint64_t sample = 0) const;
 
    virtual void copy_data (const BitSeries* data, uint64_t idat_start = 0, uint64_t ndat = 0);
 
    uint64_t get_size () const { return data_size; }
 
    virtual void append (const BitSeries* little);
 
    void set_input_sample (int64_t sample) { input_sample = sample; }
 
    int64_t get_input_sample (Input* input = 0) const;
 
    const Input* get_loader() const { return input; }
 
    void set_memory (Memory*);
 
    Memory* get_memory () { return memory; }
 
    void internal_match (const BitSeries*);
 
    void copy_configuration (const Observation* copy);
 
    class Extension : public Reference::Able { };
 
    void set_extension (Extension* ext) { extension = ext; }
    bool has_extension () { return extension; }
    Extension* get_extension () { return extension; }
    const Extension* get_extension () const { return extension; }
 
  protected:
 
    friend class Unpacker;
 
    unsigned char* data;
 
 
    int64_t data_size;
 
    int64_t input_sample;
 
    unsigned request_offset;
 
    uint64_t request_ndat;
 
    Input* input;
 
    Reference::To<Memory> memory;
 
    Reference::To<Extension> extension;
 
  };
  
}
 
#endif