BlobArray.h

Go to the documentation of this file.

// BlobArray.h: Blob handling for arrays
//
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef LOFAR_BLOB_BLOBARRAY_H
#define LOFAR_BLOB_BLOBARRAY_H
 
#include "BlobOStream.h"
#include "BlobIStream.h"
#include <vector>
#if defined(HAVE_BLITZ)
#include <blitz/array.h>
#endif
#if defined(HAVE_AIPSPP)
#include <casacore/casa/Arrays/Array.h>
#endif
 
namespace dp3 {
namespace blob {
 
 
 
template <typename T>
BlobOStream& putBlobArray(BlobOStream& bs, const T* data, const uint64_t* shape,
                          uint16_t ndim, bool fortranOrder);
template <typename T>
BlobOStream& putBlobVector(BlobOStream& bs, const T* data, uint64_t size);
 
template <typename T>
uint64_t setSpaceBlobArray1(BlobOStream& bs, bool useBlobHeader, uint64_t size0,
                            unsigned int alignment = 0);
template <typename T>
uint64_t setSpaceBlobArray2(BlobOStream& bs, bool useBlobHeader, uint64_t size0,
                            uint64_t size1, bool fortranOrder,
                            unsigned int alignment = 0);
template <typename T>
uint64_t setSpaceBlobArray3(BlobOStream& bs, bool useBlobHeader, uint64_t size0,
                            uint64_t size1, uint64_t size2, bool fortranOrder,
                            unsigned int alignment = 0);
template <typename T>
uint64_t setSpaceBlobArray4(BlobOStream& bs, bool useBlobHeader, uint64_t size0,
                            uint64_t size1, uint64_t size2, uint64_t size3,
                            bool fortranOrder, unsigned int alignment = 0);
template <typename T>
uint64_t setSpaceBlobArray(BlobOStream& bs, bool useBlobHeader,
                           const std::vector<uint64_t>& shape,
                           bool fortranOrder, unsigned int alignment = 0);
template <typename T>
uint64_t setSpaceBlobArray(BlobOStream& bs, bool useBlobHeader,
                           const uint64_t* shape, uint16_t ndim,
                           bool fortranOrder, unsigned int alignment = 0);
 
#if defined(HAVE_BLITZ)
template <typename T, unsigned int N>
BlobOStream& operator<<(BlobOStream&, const blitz::Array<T, N>&);
 
template <typename T, unsigned int N>
BlobIStream& operator>>(BlobIStream&, blitz::Array<T, N>&);
#endif
 
#if defined(HAVE_AIPSPP)
template <typename T>
BlobOStream& operator<<(BlobOStream&, const casacore::Array<T>&);
 
template <typename T>
BlobIStream& operator>>(BlobIStream&, casacore::Array<T>&);
 
BlobOStream& operator<<(BlobOStream&, const casacore::IPosition&);
BlobIStream& operator>>(BlobIStream&, casacore::IPosition&);
#endif
 
BlobOStream& operator<<(BlobOStream&, const std::vector<bool>&);
template <typename T>
BlobOStream& operator<<(BlobOStream&, const std::vector<T>&);
 
BlobIStream& operator>>(BlobIStream&, std::vector<bool>&);
template <typename T>
BlobIStream& operator>>(BlobIStream&, std::vector<T>&);
 
template <typename T>
BlobIStream& getBlobArray(BlobIStream& bs, T*& arr,
                          std::vector<uint64_t>& shape, bool fortranOrder);
 
template <typename T>
uint64_t getSpaceBlobArray(BlobIStream& bs, bool useBlobHeader,
                           std::vector<uint64_t>& shape, bool fortranOrder);
 
template <typename T>
inline uint64_t setSpaceBlobArray1(BlobOStream& bs, bool useBlobHeader,
                                   uint64_t size0, unsigned int alignment) {
  return setSpaceBlobArray<T>(bs, useBlobHeader, &size0, 1, true, alignment);
}
 
template <typename T>
inline BlobOStream& operator<<(BlobOStream& bs, const std::vector<T>& vec) {
  return putBlobVector(bs, vec.empty() ? nullptr : &(vec[0]), vec.size());
}
 
template <typename T>
inline BlobOStream& putBlobVector(BlobOStream& bs, const T* vec,
                                  uint64_t size) {
  return putBlobArray(bs, vec, &size, 1, true);
}
 
uint64_t putBlobArrayHeader(BlobOStream& bs, bool useBlobHeader,
                            const std::string& headerName,
                            const uint64_t* shape, uint16_t ndim,
                            bool fortranOrder, unsigned int alignment);
 
inline unsigned int getBlobArrayStart(BlobIStream& bs, bool& fortranOrder,
                                      uint16_t& ndim) {
  unsigned char nalign;
  bs >> fortranOrder >> nalign >> ndim;
  return nalign;
}
 
void convertArrayHeader(common::DataFormat, char* header, bool useBlobHeader);
 
uint64_t getBlobArrayShape(BlobIStream& bs, uint64_t* shape, unsigned int ndim,
                           bool swapAxes, unsigned int nalign);
 
template <typename T>
void putBlobArrayData(BlobOStream& bs, const T* data, uint64_t nr);
 
template <typename T>
void getBlobArrayData(BlobIStream& bs, T* data, uint64_t nr);
 
#define BLOBARRAY_PUTGET_SPEC(TP)                                              \
  template <>                                                                  \
  inline void putBlobArrayData(BlobOStream& bs, const TP* data, uint64_t nr) { \
    bs.put(data, nr);                                                          \
  }                                                                            \
  template <>                                                                  \
  inline void getBlobArrayData(BlobIStream& bs, TP* data, uint64_t nr) {       \
    bs.get(data, nr);                                                          \
  }
BLOBARRAY_PUTGET_SPEC(bool)
BLOBARRAY_PUTGET_SPEC(int8_t)
BLOBARRAY_PUTGET_SPEC(uint8_t)
BLOBARRAY_PUTGET_SPEC(int16_t)
BLOBARRAY_PUTGET_SPEC(uint16_t)
BLOBARRAY_PUTGET_SPEC(int32_t)
BLOBARRAY_PUTGET_SPEC(uint32_t)
BLOBARRAY_PUTGET_SPEC(int64_t)
BLOBARRAY_PUTGET_SPEC(uint64_t)
BLOBARRAY_PUTGET_SPEC(float)
BLOBARRAY_PUTGET_SPEC(double)
BLOBARRAY_PUTGET_SPEC(std::complex<float>)
BLOBARRAY_PUTGET_SPEC(std::complex<double>)
BLOBARRAY_PUTGET_SPEC(std::string)
 
 
}  // namespace blob
}  // namespace dp3
 
#include "BlobArray.tcc"
 
using dp3::blob::operator<<;
using dp3::blob::operator>>;
using dp3::blob::getBlobArray;
using dp3::blob::getSpaceBlobArray;
using dp3::blob::putBlobArray;
using dp3::blob::putBlobVector;
using dp3::blob::setSpaceBlobArray;
using dp3::blob::setSpaceBlobArray1;
using dp3::blob::setSpaceBlobArray2;
using dp3::blob::setSpaceBlobArray3;
using dp3::blob::setSpaceBlobArray4;
 
#endif