file.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <map>
#include <memory>
#include <sstream>
#include <string>
 
namespace jaffarCommon
{
 
namespace file
{
 
static __JAFFAR_COMMON_INLINE__ std::string slurp(std::ifstream& in)
{
  std::ostringstream sstr;
  sstr << in.rdbuf();
  return sstr.str();
}
 
static __JAFFAR_COMMON_INLINE__ bool loadStringFromFile(std::string& dst, const std::string& fileName)
{
  std::ifstream fi(fileName);
 
  // If file not found or open, return false
  if (fi.good() == false) return false;
 
  // Reading entire file
  dst = slurp(fi);
 
  // Closing file
  fi.close();
 
  return true;
}
 
static __JAFFAR_COMMON_INLINE__ bool saveStringToFile(const std::string& src, const std::string& fileName)
{
  FILE* fid = fopen(fileName.c_str(), "w");
  if (fid != NULL)
  {
    fwrite(src.c_str(), 1, src.size(), fid);
    fclose(fid);
    return true;
  }
  return false;
}
 
class MemoryFileDirectory;
 
class MemoryFile
{
public:
  friend class MemoryFileDirectory;
 
  MemoryFile()                      = default;
  MemoryFile(const MemoryFile&)     = delete;
  void operator=(const MemoryFile&) = delete;
 
  ~MemoryFile() { free(_buffer); }
 
  static __JAFFAR_COMMON_INLINE__ int64_t fread(void* const buffer, const size_t size, const size_t count, MemoryFile* const file)
  {
    // Check if file is closed
    if (file->isOpened() == false)
    {
      file->_errorCode = -1;
      return file->_errorCode;
    }
 
    // Refuse operation if file is write only
    if (file->isWriteOnly() == true)
    {
      file->_errorCode = -2;
      return file->_errorCode;
    }
 
    // Ensuring we don't exceed mem buffer size (guarding against a zero element size to avoid division by zero)
    size_t newCount = count;
    if (size > 0 && file->_head + (size * count) > file->_size) newCount = (file->_size - file->_head) / size;
 
    // Getting requested size
    const size_t requestedSize = size * newCount;
 
    // Performing memcpy
    if (requestedSize > 0) std::memcpy(buffer, &file->_buffer[file->_head], requestedSize);
 
    // Advancing head
    file->_head += requestedSize;
 
    // Calling corresponding callback, if defined
    if (file->_readCallbackDefined == true) file->_readCallback(requestedSize, file);
 
    // Returning element count read
    file->_errorCode = 0;
    return newCount;
  }
 
  static __JAFFAR_COMMON_INLINE__ int64_t fwrite(const void* buffer, const size_t size, const size_t count, MemoryFile* const file)
  {
    // Check if file is closed
    if (file->isOpened() == false)
    {
      file->_errorCode = -1;
      return file->_errorCode;
    }
 
    // Refuse operation if file is read only
    if (file->isReadOnly() == true)
    {
      file->_errorCode = -2;
      return file->_errorCode;
    }
 
    // Getting requested size
    const size_t requestedSize = size * count;
 
    // Checking if internal buffer needs to be resized
    const size_t endHeadPos = file->_head + requestedSize;
    if (endHeadPos > file->_bufferSize) file->resizeToFit(endHeadPos + 1);
 
    // Performing memcpy
    if (requestedSize > 0) memcpy(&file->_buffer[file->_head], buffer, requestedSize);
 
    // Advancing head until the next
    file->_head += requestedSize;
    if (file->_head > file->_size) file->_size = file->_head;
 
    // Calling corresponding callback, if defined
    if (file->_writeCallbackDefined == true) file->_writeCallback(requestedSize, file);
 
    // Returning element count written
    file->_errorCode = 0;
    return count;
  }
 
  static __JAFFAR_COMMON_INLINE__ int64_t ftello64(MemoryFile* const file) { return ftell(file); }
 
  static __JAFFAR_COMMON_INLINE__ int64_t ftell(MemoryFile* const file)
  {
    // Check if file is closed
    if (file->isOpened() == false)
    {
      file->_errorCode = -1;
      return file->_errorCode;
    }
 
    file->_errorCode = 0;
    return file->_head;
  }
 
  static __JAFFAR_COMMON_INLINE__ void rewind(MemoryFile* const file)
  {
    // Check if file is closed
    if (file->isOpened() == false)
    {
      file->_errorCode = -1;
      return;
    }
 
    file->_errorCode = 0;
    file->_head      = 0;
  }
 
  static __JAFFAR_COMMON_INLINE__ int fflush(MemoryFile* file)
  {
    // Check if file is closed
    if (file->isOpened() == false)
    {
      file->_errorCode = -1;
      return file->_errorCode;
    }
 
    file->_errorCode = 0;
    return 0;
  }
 
  static __JAFFAR_COMMON_INLINE__ int fseeko64(MemoryFile* const file, const int64_t offset, const int origin) { return fseek(file, offset, origin); }
 
  static __JAFFAR_COMMON_INLINE__ int fseek(MemoryFile* const file, const int64_t offset, const int origin)
  {
    // Check if file is closed
    if (file->isOpened() == false)
    {
      file->_errorCode = -1;
      return file->_errorCode;
    }
 
    int64_t startPos = file->_head;
    if (origin == SEEK_SET) startPos = 0;
    if (origin == SEEK_END) startPos = file->_size;
 
    int64_t desiredPos = startPos + offset;
    if (desiredPos < 0)
    {
      file->_errorCode = -2;
      return file->_errorCode;
    }
    if (desiredPos > (int64_t)file->_size)
    {
      file->_errorCode = -3;
      return file->_errorCode;
    }
 
    file->_head      = desiredPos;
    file->_errorCode = 0;
    return 0;
  }
 
  static __JAFFAR_COMMON_INLINE__ int feof(MemoryFile* const file)
  {
    // Check if file is closed
    if (file->isOpened() == false)
    {
      file->_errorCode = -1;
      return file->_errorCode;
    }
 
    file->_errorCode = 0;
    return file->_head == file->_size;
  }
 
  static __JAFFAR_COMMON_INLINE__ void clearerr(MemoryFile* const file)
  {
    // Check if file is closed
    if (file->isOpened() == false) return;
 
    file->_errorCode = 0;
  }
 
  static __JAFFAR_COMMON_INLINE__ int ferror(MemoryFile* const file) { return file->_errorCode; }
 
  __JAFFAR_COMMON_INLINE__ void setReadOnly() { _readonly = true; }
 
  __JAFFAR_COMMON_INLINE__ void unsetReadOnly() { _readonly = false; }
 
  __JAFFAR_COMMON_INLINE__ void setWriteOnly() { _writeonly = true; }
 
  __JAFFAR_COMMON_INLINE__ void unsetWriteOnly() { _writeonly = false; }
 
  __JAFFAR_COMMON_INLINE__ void setOpened() { _opened = true; }
 
  __JAFFAR_COMMON_INLINE__ void unsetOpened() { _opened = false; }
 
  __JAFFAR_COMMON_INLINE__ bool isReadOnly() const { return _readonly; }
 
  __JAFFAR_COMMON_INLINE__ bool isWriteOnly() const { return _writeonly; }
 
  __JAFFAR_COMMON_INLINE__ bool isOpened() const { return _opened; }
 
  __JAFFAR_COMMON_INLINE__ void setWriteCallback(const std::function<void(const int64_t, MemoryFile*)> callback)
  {
    _writeCallback        = callback;
    _writeCallbackDefined = true;
  }
 
  __JAFFAR_COMMON_INLINE__ void setReadCallback(const std::function<void(const int64_t, MemoryFile*)> callback)
  {
    _readCallback        = callback;
    _readCallbackDefined = true;
  }
 
  __JAFFAR_COMMON_INLINE__ void unsetWriteCallback() { _writeCallbackDefined = false; }
 
  __JAFFAR_COMMON_INLINE__ void unsetReadCallback() { _readCallbackDefined = false; }
 
  __JAFFAR_COMMON_INLINE__ int resize(const size_t newSize)
  {
    // Check if file is closed
    if (isOpened() == false)
    {
      _errorCode = -1;
      return _errorCode;
    }
 
    // Refuse operation if file is read only
    if (isReadOnly() == true)
    {
      _errorCode = -2;
      return _errorCode;
    }
 
    // First, assign new size
    // const size_t oldSize = _size;
    _size = newSize;
 
    // Then, resize the internal buffer, if needed
    if (_bufferSize < _size)
    {
      resizeToFit(_size);
      if (_buffer == nullptr) return -1;
    }
 
    // Then check head in case of shrinking file
    if (_head > _size) _head = _size;
 
    _errorCode = 0;
    return 0;
  }
 
  __JAFFAR_COMMON_INLINE__ void setSize(const size_t size) { _size = size; }
 
  __JAFFAR_COMMON_INLINE__ size_t getSize() const { return _size; }
 
private:
  uint8_t* getBuffer() const { return _buffer; }
 
  void resizeToFit(const size_t target)
  {
    // Getting current buffer size
    size_t newBufferSize = _bufferSize;
    if (newBufferSize == 0) newBufferSize = 1;
 
    // Duplicating new buffer size until the target fits
    while (newBufferSize < target) newBufferSize <<= 1;
 
    // Reallocating buffer. Only commit the new pointer/size if realloc succeeds, so a failed
    // reallocation leaves the original buffer (and its size) intact instead of leaking it and
    // claiming a capacity the buffer does not actually have.
    uint8_t* newBuffer = (uint8_t*)realloc(_buffer, newBufferSize);
    if (newBuffer == nullptr) return;
    _buffer     = newBuffer;
    _bufferSize = newBufferSize;
  }
 
  size_t _size = 0;
 
  size_t _bufferSize = 0;
 
  uint8_t* _buffer = nullptr;
 
  bool _readonly = false;
 
  bool _writeonly = false;
 
  bool _opened = false;
 
  size_t _head = 0;
 
  int _errorCode = 0;
 
  bool _writeCallbackDefined = false;
 
  std::function<void(const int64_t, MemoryFile* const)> _writeCallback;
 
  bool _readCallbackDefined = false;
 
  std::function<void(const int64_t, MemoryFile* const)> _readCallback;
};
 
class MemoryFileDirectory
{
public:
  MemoryFileDirectory() = default;
 
  __JAFFAR_COMMON_INLINE__ MemoryFile* fopen(const std::string filename, const std::string mode)
  {
    // Parsing mode
    mode_t openMode = mode_t::none;
    if (mode.find("r") != std::string::npos) openMode = mode_t::read;
    if (mode.find("w") != std::string::npos)
    {
      if (openMode != mode_t::none) return NULL; // Conflicting modes selected
      openMode = mode_t::write;
    }
    if (mode.find("a") != std::string::npos)
    {
      if (openMode != mode_t::none) return NULL; // Conflicting modes selected
      openMode = mode_t::append;
    }
 
    // If appending, fail because mem buffers have static size
    if (openMode == mode_t::append) return NULL;
 
    // If no mode chosen, fail
    if (openMode == mode_t::none) return NULL;
 
    // Parsing extended
    bool extendedMode = false;
    if (mode.find("+") != std::string::npos) extendedMode = true;
 
    // Parsing extended
    bool noCreateMode = false;
    if (mode.find("x") != std::string::npos) noCreateMode = true;
 
    // Checking if file already exists
    bool fileExists = _fileMap.contains(filename);
 
    // Check if file needs to be created
    bool createFile = false;
 
    // Evaluating the case where the file doesn't exist
    if (fileExists == false)
    {
      // Check if the no-create flag has been provided
      if (noCreateMode == true) return NULL;
 
      // If reading, return NULL
      if (openMode == mode_t::read) return NULL;
 
      // Otherwise, create a new one
      createFile = true;
    }
 
    // Evaluating the case where the file does exist
    if (fileExists == true)
    {
      // Check if opened. If it is, then we cannot re-open it now
      if (_fileMap.at(filename)->isOpened() == true) return NULL;
 
      // If writing, overwrite file
      if (openMode == mode_t::write) createFile = true;
    }
 
    // Creating new file, if required
    if (createFile == true) _fileMap[filename] = std::make_unique<MemoryFile>();
 
    // Getting file
    MemoryFile* file = _fileMap.at(filename).get();
 
    // Otherwise, we set it as opened
    file->setOpened();
 
    // If reading, set as read only
    if (openMode == mode_t::read)
    {
      file->setReadOnly();
      file->unsetWriteOnly();
    }
 
    // If writing, set as write only
    if (openMode == mode_t::write)
    {
      file->setWriteOnly();
      file->unsetReadOnly();
    }
 
    // If extended mode, all operations are permitted
    if (extendedMode == true)
    {
      file->unsetWriteOnly();
      file->unsetReadOnly();
    }
 
    // Set file head to the start
    MemoryFile::rewind(file);
 
    // Return file
    return file;
  }
 
  int fclose(MemoryFile* const file)
  {
    if (file == NULL) return -1;
 
    // Check if file already closed
    if (file->isOpened() == false) return -2;
 
    // Set the file as closed
    file->unsetOpened();
 
    return 0;
  }
 
  int fdestroy(const std::string& filename)
  {
    // Checking if file already exists
    if (_fileMap.contains(filename) == false) return -1;
 
    // Getting file
    MemoryFile* file = _fileMap.at(filename).get();
 
    // Check if opened. Cannot delete it yet
    if (file->isOpened() == true) return -2;
 
    // Delete it now
    _fileMap.erase(filename);
 
    return 0;
  }
 
  bool contains(const std::string& filename) const { return _fileMap.contains(filename); }
 
  int64_t getFileSize(const std::string& filename) const
  {
    if (contains(filename) == false) return -1;
    return _fileMap.at(filename)->getSize();
  }
 
  uint8_t* getFileBuffer(const std::string& filename) const
  {
    if (contains(filename) == false) return nullptr;
    return _fileMap.at(filename)->getBuffer();
  }
 
private:
  enum mode_t
  {
    none,
    read,
    write,
    append
  };
 
  std::map<std::string, std::unique_ptr<MemoryFile>> _fileMap;
};
 
} // namespace file
 
} // namespace jaffarCommon