BinaryFile.h

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 +
#pragma once
 
#include "MantidKernel/DllConfig.h"
 
#include <Poco/File.h>
#include <Poco/Path.h>
#include <fstream>
#include <memory>
#include <string>
#include <vector>
 
namespace Mantid {
namespace Kernel {
 
static const size_t DEFAULT_BLOCK_SIZE = 100000; // 100,000
 
static const size_t MAX_BLOCK_SIZE = 100000000; // 100 million
 
static const size_t MIN_BLOCK_SIZE = 1000;
 
template <typename T> class DLLExport BinaryFile {
public:
  //------------------------------------------------------------------------------------
  BinaryFile() : handle(nullptr), num_elements(0), offset(0) {}
 
  //------------------------------------------------------------------------------------
  BinaryFile(std::string filename) { this->open(filename); }
 
  ~BinaryFile() { this->close(); }
 
  //------------------------------------------------------------------------------------
  void open(const std::string &filename) {
    this->handle.reset(nullptr);
    if (!Poco::File(filename).exists()) {
      std::stringstream msg;
      msg << "BinaryFile::open: File " << filename << " was not found.";
      throw std::invalid_argument("File does not exist.");
    }
    // Open the file
    this->handle = std::make_unique<std::ifstream>(filename.c_str(), std::ios::binary);
    // Count the # of elements.
    this->num_elements = this->getFileSize();
    // Make sure we are starting at 0
    this->offset = 0;
  }
 
  //------------------------------------------------------------------------------------
  void close() { handle.reset(nullptr); }
 
  //-----------------------------------------------------------------------------
  size_t getNumElements() const { return this->num_elements; }
 
  size_t getOffset() const { return this->offset; }
 
  //-----------------------------------------------------------------------------
  size_t getBufferSize(const size_t num_items) const {
    if (num_items < DEFAULT_BLOCK_SIZE)
      return num_items;
    else
      return DEFAULT_BLOCK_SIZE;
  }
 
  //-----------------------------------------------------------------------------
  std::vector<T> loadAll() {
    if (!handle) {
      throw std::runtime_error("BinaryFile: file is not open.");
    }
 
    // Initialize the pointer
    std::vector<T> data;
 
    // A buffer to load from
    size_t buffer_size = getBufferSize(num_elements);
    auto buffer = std::make_unique<T[]>(buffer_size);
 
    // Make sure we are at the beginning
    offset = 0;
    handle->seekg(0, std::ios::beg);
 
    while (offset < num_elements) {
      // Load that block of data
      const auto loaded_size = loadBlock(buffer.get(), buffer_size);
      // Insert into the data
      data.insert(data.end(), buffer.get(), std::next(buffer.get(), loaded_size));
    }
 
    // Close the file, since we are done.
    this->close();
 
    // Here's your vector!
    return data;
  }
 
  //-----------------------------------------------------------------------------
  std::vector<T> loadAllIntoVector() {
    if (!handle) {
      throw std::runtime_error("BinaryFile: file is not open.");
    }
    std::vector<T> data;
 
    // A buffer to load from
    size_t buffer_size = getBufferSize(num_elements);
    auto buffer = new T[buffer_size];
 
    // Make sure we are at the beginning
    offset = 0;
    handle->seekg(0, std::ios::beg);
 
    while (offset < num_elements) {
      // Load that block of data
      const auto loaded_size = loadBlock(buffer, buffer_size);
      // Insert into the data
      data.insert(data.end(), buffer, (buffer + loaded_size));
    }
 
    // Close the file, since we are done.
    this->close();
    // Free memory
    delete[] buffer;
 
    return data;
  }
 
  //-----------------------------------------------------------------------------
  size_t loadBlock(T *buffer, size_t block_size) {
    if (!handle) {
      throw std::runtime_error("BinaryFile: file is not open.");
    }
 
    size_t loaded_size;
    // Limit how much is loaded
    loaded_size = block_size;
    if (offset + loaded_size > num_elements)
      loaded_size = num_elements - offset;
    // Read it right into the buffer
    handle->read(reinterpret_cast<char *>(buffer), loaded_size * obj_size);
    offset += loaded_size;
    return loaded_size;
  }
 
  //-----------------------------------------------------------------------------
  size_t loadBlockAt(T *buffer, size_t newOffset, size_t block_size) {
    if (!handle) {
      throw std::runtime_error("BinaryFile: file is not open.");
    }
    // Change our offset to the new spot.
    offset = newOffset;
    handle->seekg(sizeof(T) * offset, std::ios::beg);
    return loadBlock(buffer, block_size);
  }
 
private:
  size_t getFileSize() {
    this->obj_size = sizeof(T);
 
    if (!handle) {
      throw std::runtime_error("BinaryFile::getFileSize: Cannot find the size "
                               "of a file from a null handle");
    }
 
    // get the size of the file in bytes and reset the handle back to the
    // beginning
    handle->seekg(0, std::ios::end);
    size_t filesize = static_cast<size_t>(handle->tellg());
    handle->seekg(0, std::ios::beg);
 
    // check the file is a compatible size
    if (filesize % obj_size != 0) {
      std::stringstream msg;
      msg << "BinaryFile::getFileSize: File size is not compatible with data "
             "size ";
      msg << filesize << "%" << obj_size << "=";
      msg << filesize % obj_size;
      throw std::runtime_error(msg.str());
    }
 
    return filesize / sizeof(T);
  }
 
  std::unique_ptr<std::ifstream> handle;
  size_t obj_size;
  size_t num_elements;
  size_t offset;
};
 
} // Namespace Kernel
 
} // Namespace Mantid