ASCIIObservation.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2007 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// dspsr/Kernel/Classes/dsp/ASCIIObservation.h
 
#ifndef __ASCIIObservation_h
#define __ASCIIObservation_h
 
#include "dsp/Observation.h"
#include "ascii_header.h"
 
namespace dsp {
 
 
  class ASCIIObservation : public Observation
  {
 
  public:
 
    ASCIIObservation (const char* header=0);
 
    ASCIIObservation (const Observation*);
 
    ASCIIObservation* clone() const override;
 
    void load (const char* header);
 
    void unload (char* header);
 
    uint64_t get_offset_bytes () const { return offset_bytes; }
 
    void set_required (std::string key, bool required=true);
 
    bool is_required (std::string key);
 
    template <typename T>
    int custom_header_get (std::string key, const char *format, T result) const;
 
    const char* get_header () const { return loaded_header.c_str(); }
 
    char* get_header () { return const_cast<char*>(loaded_header.c_str()); }
 
  protected:
 
    std::string hdr_version;
 
    std::vector< std::string > required_keys;
 
    template <typename T>
    int ascii_header_check (const char *header, std::string key, const char *format, T result);
 
    template <typename T>
    void load_str_into_array (std::string from, T* buffer, unsigned bufsize);
 
    uint64_t offset_bytes;
 
    std::string loaded_header;
  };
 
}
 
template <typename T>
void dsp::ASCIIObservation::load_str_into_array ( std::string from, T* buffer, unsigned bufsize )
{
  std::string val;
  std::string delimiter = ",";
  size_t pos=0;
  for (unsigned i=0; i<bufsize; i++) {
    pos = from.find(delimiter);
    val = from.substr(0, pos);
    buffer[i] = fromstring<T>(val);
    from.erase(0, pos + delimiter.length());
  }
}
 
 
template <typename T>
int dsp::ASCIIObservation::custom_header_get ( std::string key, const char *format, T result) const
{
  int rv = ascii_header_get (loaded_header.c_str(), key.c_str(), format, result);
  if ( rv > 0)
    return rv;
  throw Error (InvalidState, "ASCIIObservation::custom_header_get", "failed to find " + key);
}
 
 
template <typename T>
int dsp::ASCIIObservation::ascii_header_check (const char *header,
    std::string key, const char *format, T result)
{
  int rv = ascii_header_get(header, key.c_str(), format, result);
 
  if ( rv>0 || !is_required(key) )
    return rv;
 
  throw Error (InvalidState, "ASCIIObservation", "failed load " + key);
}
 
#endif