BlobIStream.h

Go to the documentation of this file.

// BlobIStream.h: Input stream for a blob
//
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef LOFAR_BLOB_BLOBISTREAM_H
#define LOFAR_BLOB_BLOBISTREAM_H
 
#include "common/DataFormat.h"
#include "common/DataConvert.h"
 
#include "BlobIBuffer.h"
 
#include <stack>
#include <vector>
#include <string>
#include <complex>
 
namespace dp3 {
namespace blob {
 
 
 
 
class BlobIStream {
 public:
  explicit BlobIStream(BlobIBuffer&);
 
  ~BlobIStream();
 
  void clear();
 
  int getStart(const std::string& objectType);
  int getStart(const char* objectType = "");
 
  uint64_t getEnd();
 
  const std::string& getNextType();
  const std::string& getNextType(uint64_t& size);
 
  BlobIStream& operator>>(bool& value);
  BlobIStream& operator>>(char& value);
  BlobIStream& operator>>(int8_t& value);
  BlobIStream& operator>>(uint8_t& value);
  BlobIStream& operator>>(int16_t& value);
  BlobIStream& operator>>(uint16_t& value);
  BlobIStream& operator>>(int32_t& value);
  BlobIStream& operator>>(uint32_t& value);
  BlobIStream& operator>>(int64_t& value);
  BlobIStream& operator>>(uint64_t& value);
  BlobIStream& operator>>(float& value);
  BlobIStream& operator>>(double& value);
  template <class T>
  BlobIStream& operator>>(std::complex<T>& value);
  //      BlobIStream& operator>> (i4complex& value);
  //      BlobIStream& operator>> (i16complex& value);
  //      BlobIStream& operator>> (u16complex& value);
  BlobIStream& operator>>(std::complex<float>& value);
  BlobIStream& operator>>(std::complex<double>& value);
  BlobIStream& operator>>(std::string& value);
 
  void get(bool* values, uint64_t nrval);
  void get(char* values, uint64_t nrval);
  void get(int8_t* values, uint64_t nrval);
  void get(uint8_t* values, uint64_t nrval);
  void get(int16_t* values, uint64_t nrval);
  void get(uint16_t* values, uint64_t nrval);
  void get(int32_t* values, uint64_t nrval);
  void get(uint32_t* values, uint64_t nrval);
  void get(int64_t* values, uint64_t nrval);
  void get(uint64_t* values, uint64_t nrval);
  void get(float* values, uint64_t nrval);
  void get(double* values, uint64_t nrval);
  template <class T>
  void get(std::complex<T>* values, uint64_t nrval);
  void get(std::complex<float>* values, uint64_t nrval);
  void get(std::complex<double>* values, uint64_t nrval);
  void get(std::string* values, uint64_t nrval);
 
  void get(std::vector<bool>& values);
  template <typename T>
  void get(std::vector<T>& values);
 
  void getBoolVec(std::vector<bool>& values, uint64_t size);
 
  int64_t getSpace(uint64_t nbytes);
 
  unsigned int align(unsigned int n);
 
  int64_t tellPos() const;
 
  bool mustConvert() const;
  dp3::common::DataFormat dataFormat() const;
 
 private:
  void getBuf(void* buf, uint64_t sz);
 
  void checkGet() const;
  void throwGet() const;
 
  bool itsSeekable;
  bool itsMustConvert;
  bool itsHasCachedType;
  uint64_t itsCurLength;
  unsigned int itsLevel;
  int itsVersion;
  dp3::common::DataFormat itsDataFormat;
  std::string itsObjectType;
  std::stack<uint64_t> itsObjTLN;
  std::stack<uint64_t> itsObjLen;
  BlobIBuffer* itsStream;
};
 
 
inline void BlobIStream::clear() {
  itsCurLength = 0;
  itsLevel = 0;
  itsHasCachedType = false;
}
 
inline int BlobIStream::getStart(const char* objectType) {
  return getStart(std::string(objectType));
}
 
inline int64_t BlobIStream::tellPos() const { return itsStream->tellPos(); }
 
inline bool BlobIStream::mustConvert() const { return itsMustConvert; }
 
inline dp3::common::DataFormat BlobIStream::dataFormat() const {
  return itsDataFormat;
}
 
template <typename T>
inline BlobIStream& BlobIStream::operator>>(std::complex<T>& value) {
  getBuf(&value, sizeof(std::complex<T>));
  if (itsMustConvert) {
    dp3::common::dataConvert(itsDataFormat, &value, 1);
  }
  return *this;
}
template <typename T>
inline void BlobIStream::get(std::complex<T>* values, uint64_t nrval) {
  getBuf(values, nrval * sizeof(std::complex<T>));
  if (itsMustConvert) {
    dp3::common::dataConvert(itsDataFormat, values, nrval);
  }
}
 
template <typename T>
inline void BlobIStream::get(std::vector<T>& vec) {
  uint64_t sz;
  operator>>(sz);
  vec.resize(sz);
  get(&vec[0], sz);
}
inline void BlobIStream::get(std::vector<bool>& vec) {
  uint64_t sz;
  operator>>(sz);
  getBoolVec(vec, sz);
}
 
inline void BlobIStream::checkGet() const {
  if (itsLevel == 0) throwGet();
}
 
}  // namespace blob
}  // namespace dp3
 
#endif