FileDescriptor.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 +
#include "MantidKernel/FileDescriptor.h"
#include "MantidKernel/Strings.h"
 
#include <filesystem>
#include <stdexcept>
 
namespace Mantid::Kernel {
//----------------------------------------------------------------------------------------------
// Public static methods
//----------------------------------------------------------------------------------------------
bool FileDescriptor::isAscii(const std::string &filename, const size_t nbytes) {
  std::ifstream dataStream(filename.c_str(), std::ios::in | std::ios::binary);
  if (!dataStream) {
    throw std::invalid_argument("FileDescriptor::isAscii() - Unable to open file '" + filename + "'");
  }
  return FileDescriptor::isAscii(dataStream, nbytes);
}
 
bool FileDescriptor::isAscii(std::istream &data, const size_t nbytes) {
  const std::streampos startPos = data.tellg();
  char byte('\0');
  size_t counter(0);
  bool result(true);
  while (counter < nbytes) {
    data >> byte;
    if (!data) // reading error
    {
      data.clear();
      break;
    }
    auto ch = static_cast<unsigned long>(byte);
    if (!(ch <= 0x7F)) // non-ascii
    {
      result = false;
      break;
    }
    ++counter;
  }
 
  data.seekg(startPos);
  return result;
}
 
bool FileDescriptor::isAscii(FILE *file, const size_t nbytes) {
  // read the data and reset the seek index back to the beginning
  auto dataArray = new char[nbytes];
  const char *pend = &dataArray[fread(dataArray, 1, nbytes, file)];
  int retval = fseek(file, 0, SEEK_SET);
  if (retval < 0)
    throw std::runtime_error("FileDescriptor::isAscii - Cannot change position "
                             "to the beginning of the file with fseek");
 
  // Call it a binary file if we find a non-ascii character in the
  // first nbytes bytes of the file.
  bool result = true;
  for (char *p = dataArray; p < pend; ++p) {
    auto ch = static_cast<unsigned long>(*p);
    if (!(ch <= 0x7F)) {
      result = false;
      break;
    }
  }
  delete[] dataArray;
 
  return result;
}
 
bool FileDescriptor::isEmpty(const std::string &filename) {
  std::ifstream file(filename.c_str());
 
  if (!file) {
    throw std::invalid_argument("FileDescriptor::isEmpty() - Unable to open file '" + filename + "'");
  }
 
  return file.peek() == std::ifstream::traits_type::eof();
}
 
//----------------------------------------------------------------------------------------------
// Public methods
//----------------------------------------------------------------------------------------------
 
FileDescriptor::FileDescriptor(const std::string &filename) : m_filename(), m_extension(), m_file(), m_ascii(false) {
  if (filename.empty()) {
    throw std::invalid_argument("FileDescriptor() - Empty filename '" + filename + "'");
  }
  if (!std::filesystem::exists(filename)) {
    throw std::invalid_argument("FileDescriptor() - File '" + filename + "' does not exist");
  }
  initialize(filename);
}
 
FileDescriptor::~FileDescriptor() { m_file.close(); }
 
void FileDescriptor::resetStreamToStart() {
  m_file.close(); // reset all flags
  // If the stream was closed, reopen it
  if (!m_file.is_open()) {
    m_file.open(m_filename.c_str(), std::ios::in | std::ios::binary);
  } else {
    m_file.seekg(0);
  }
}
 
bool FileDescriptor::isXML() const { return (this->isAscii() && this->extension() == ".xml"); }
 
//----------------------------------------------------------------------------------------------
// Private methods
//----------------------------------------------------------------------------------------------
 
void FileDescriptor::initialize(const std::string &filename) {
  m_filename = filename;
  m_extension = Mantid::Kernel::Strings::toLower(std::filesystem::path(filename).extension().string());
 
  m_file.open(m_filename.c_str(), std::ios::in | std::ios::binary);
  if (!m_file)
    throw std::runtime_error("FileDescriptor::initialize - Cannot open file '" + filename + "' for reading");
 
  m_ascii = FileDescriptor::isAscii(m_file);
}
 
} // namespace Mantid::Kernel