BinaryStreamReader.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
//------------------------------------------------------------------------------
// Includes
//------------------------------------------------------------------------------
#include "MantidKernel/BinaryStreamReader.h"
#include "MantidKernel/Matrix.h"
 
#include <cassert>
#include <istream>
#include <stdexcept>
 
namespace Mantid::Kernel {
 
//------------------------------------------------------------------------------
// Anonymous functions
//------------------------------------------------------------------------------
namespace {
 
template <typename T> inline void readFromStream(std::istream &stream, T &value) {
  stream.read(reinterpret_cast<char *>(&value), sizeof(T));
}
 
template <typename T> inline void readFromStream(std::istream &stream, std::vector<T> &value, size_t nvals) {
  if (value.size() < nvals)
    value.resize(nvals);
  stream.read(reinterpret_cast<char *>(value.data()), nvals * sizeof(T));
}
 
template <typename T>
inline void readFromStream(std::istream &stream, Matrix<T> &value, const std::vector<int32_t> &shape,
                           BinaryStreamReader::MatrixOrdering order) {
  assert(2 <= shape.size());
  const size_t s0(shape[0]), s1(shape[1]), totalLength(s0 * s1);
  std::vector<T> buffer;
  readFromStream(stream, buffer, totalLength);
  value = Matrix<T>(s0, s1);
  if (order == BinaryStreamReader::MatrixOrdering::RowMajor) {
    for (size_t i = 0; i < s0; ++i) {
      auto row = value[i];
      const size_t offset = i * s1;
      for (size_t j = 0; j < s1; ++j) {
        row[j] = buffer[offset + j];
      }
    }
  } else {
    for (size_t i = 0; i < s0; ++i) {
      auto row = value[i];
      for (size_t j = 0; j < s1; ++j) {
        row[j] = buffer[j * s0 + i];
      }
    }
  }
}
} // namespace
 
//------------------------------------------------------------------------------
// Public members
//------------------------------------------------------------------------------
 
BinaryStreamReader::BinaryStreamReader(std::istream &istrm)
    : m_istrm(istrm), m_strLengthSize(static_cast<uint64_t>(sizeof(int32_t))) {
  if (!istrm) {
    throw std::runtime_error("BinaryStreamReader: Input stream is in a bad state. Cannot continue.");
  }
}
 
BinaryStreamReader &BinaryStreamReader::operator>>(int16_t &value) {
  readFromStream(m_istrm, value);
  return *this;
}
 
BinaryStreamReader &BinaryStreamReader::operator>>(int32_t &value) {
  readFromStream(m_istrm, value);
  return *this;
}
 
BinaryStreamReader &BinaryStreamReader::operator>>(int64_t &value) {
  readFromStream(m_istrm, value);
  return *this;
}
 
BinaryStreamReader &BinaryStreamReader::operator>>(float &value) {
  readFromStream(m_istrm, value);
  return *this;
}
 
BinaryStreamReader &BinaryStreamReader::operator>>(double &value) {
  readFromStream(m_istrm, value);
  return *this;
}
 
BinaryStreamReader &BinaryStreamReader::operator>>(std::string &value) {
  // First read the size.
  decltype(m_strLengthSize) length(0);
  m_istrm.read(reinterpret_cast<char *>(&length), m_strLengthSize);
  // Now the value
  value.resize(static_cast<std::string::size_type>(length));
  m_istrm.read(const_cast<char *>(value.data()), static_cast<size_t>(length));
  return *this;
}
 
BinaryStreamReader &BinaryStreamReader::operator>>(uint16_t &value) {
  readFromStream(m_istrm, value);
  return *this;
}
 
BinaryStreamReader &BinaryStreamReader::operator>>(uint32_t &value) {
  readFromStream(m_istrm, value);
  return *this;
}
 
BinaryStreamReader &BinaryStreamReader::read(std::vector<int16_t> &value, const size_t nvals) {
  readFromStream(m_istrm, value, nvals);
  return *this;
}
 
BinaryStreamReader &BinaryStreamReader::read(std::vector<int32_t> &value, const size_t nvals) {
  readFromStream(m_istrm, value, nvals);
  return *this;
}
 
BinaryStreamReader &BinaryStreamReader::read(std::vector<int64_t> &value, const size_t nvals) {
  readFromStream(m_istrm, value, nvals);
  return *this;
}
 
BinaryStreamReader &BinaryStreamReader::read(std::vector<float> &value, const size_t nvals) {
  readFromStream(m_istrm, value, nvals);
  return *this;
}
 
BinaryStreamReader &BinaryStreamReader::read(std::vector<double> &value, const size_t nvals) {
  readFromStream(m_istrm, value, nvals);
  return *this;
}
 
BinaryStreamReader &BinaryStreamReader::read(std::string &value, const size_t length) {
  value.resize(length);
  m_istrm.read(const_cast<char *>(value.data()), length);
  return *this;
}
 
BinaryStreamReader &BinaryStreamReader::read(std::vector<std::string> &value, const std::vector<int32_t> &shape,
                                             BinaryStreamReader::MatrixOrdering order) {
  assert(2 <= shape.size());
 
  const size_t s0(shape[0]), s1(shape[1]), totalLength(s0 * s1);
  std::string buffer;
  this->read(buffer, totalLength);
  value.resize(s0);
  if (order == MatrixOrdering::RowMajor) {
    size_t pos(0);
    for (auto &str : value) {
      str = buffer.substr(pos, s1);
      pos += s1;
    }
  } else {
    for (size_t i = 0; i < s0; ++i) {
      auto &str = value[i];
      str.resize(s1);
      for (size_t j = 0; j < s1; ++j) {
        str[j] = buffer[j * s0 + i];
      }
    }
  }
  return *this;
}
 
BinaryStreamReader &BinaryStreamReader::read(Kernel::Matrix<float> &value, const std::vector<int32_t> &shape,
                                             BinaryStreamReader::MatrixOrdering order) {
  readFromStream(m_istrm, value, shape, order);
  return *this;
}
 
BinaryStreamReader &BinaryStreamReader::read(Kernel::Matrix<double> &value, const std::vector<int32_t> &shape,
                                             BinaryStreamReader::MatrixOrdering order) {
  readFromStream(m_istrm, value, shape, order);
  return *this;
}
 
void BinaryStreamReader::moveStreamToPosition(size_t nbytes) { m_istrm.seekg(nbytes, std::ios_base::beg); }
 
} // namespace Mantid::Kernel