FileHandle.Windows.cpp

#include "FileHandle.h"
 
#include "Unicode.h"
 
#include "../StringViewFormat.h"
 
#include "../Logging/Logger.h"
 
namespace {
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("FileHandle");
}
 
Cogs::FileHandle::~FileHandle() {
  close();
}
 
Cogs::FileHandle::Ptr Cogs::FileHandle::open(std::string_view path, OpenMode openMode, AccessMode accessMode) {
  Ptr handle = std::make_shared<FileHandle>();
 
  constexpr DWORD dwOpenMode[] = {
    CREATE_NEW,
    CREATE_ALWAYS,
    OPEN_EXISTING,
    OPEN_ALWAYS,
    TRUNCATE_EXISTING,
  };
 
  constexpr DWORD dwAccessMode[] = {
    GENERIC_READ,
    GENERIC_WRITE
  };
 
  constexpr DWORD dwShareMode[] = {
    FILE_SHARE_READ,
    0
  };
 
  handle->fileHandle = CreateFileW(Cogs::widen(path).c_str(), dwAccessMode[(int)accessMode], dwShareMode[(int)accessMode], nullptr, dwOpenMode[(int)openMode], FILE_ATTRIBUTE_NORMAL, nullptr);
 
  if (handle->fileHandle == INVALID_HANDLE_VALUE) {
    LPSTR messageBuffer = nullptr;
 
    FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                   nullptr,
                   GetLastError(),
                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                   reinterpret_cast<LPSTR>(&messageBuffer),
                   0,
                   nullptr);
 
    LOG_ERROR(logger, "Cogs::FileHandle::open(): Failed to open %.*s. Error: %s.", StringViewFormat(path), messageBuffer);
 
    LocalFree(messageBuffer);
    return Ptr();
  }
  return handle;
}
 
void Cogs::FileHandle::close() {
  if (mappedMemory) {
    ::UnmapViewOfFile(mappedMemory);
    mappedMemory = nullptr;
  }
 
  if (mapHandle) {
    ::CloseHandle(mapHandle);
    mapHandle = nullptr;
  }
 
  if (fileHandle) {
    ::CloseHandle(fileHandle);
    fileHandle = INVALID_HANDLE_VALUE;
  }
}
 
bool Cogs::FileHandle::isOpen() const {
  return fileHandle != INVALID_HANDLE_VALUE;
}
 
size_t Cogs::FileHandle::getSize() const {
  if (fileHandle != INVALID_HANDLE_VALUE) {
    DWORD highSize;
    DWORD lowSize = ::GetFileSize(fileHandle, &highSize);
  
    return (static_cast<size_t>(highSize) << 32) + lowSize;
  }
  return 0;
}
 
bool Cogs::FileHandle::write(const void* buffer, size_t size, size_t& bytesWritten)
{
  const uint8_t*  src = static_cast<const uint8_t*>(buffer);
  DWORD           justWritten;
 
  bytesWritten = 0;
 
  for (constexpr size_t limit = std::numeric_limits<DWORD>::max(); size > limit; ) {
    if (WriteFile(fileHandle, src, static_cast<DWORD>(limit), &justWritten, nullptr)) {
      src += justWritten;
      size -= justWritten;
      bytesWritten += justWritten;
    }
    else {
      LOG_ERROR(logger, "write(): Failed to write FileHandle %p. Error: %d.", fileHandle, GetLastError());
      return false;
    }
  }
  if (size) {
    if (WriteFile(fileHandle, src, static_cast<DWORD>(size), &justWritten, nullptr)) {
      bytesWritten += justWritten;
    }
    else {
      LOG_ERROR(logger, "write(): Failed to write FileHandle %p. Error: %d.", fileHandle, GetLastError());
      return false;
    }
  }
  return true;
}
 
bool Cogs::FileHandle::read(void* buffer, size_t size, size_t& bytesRead)
{
  uint8_t*  dest = reinterpret_cast<uint8_t*>(buffer);
  DWORD     justRead;
 
  bytesRead = 0;
 
  for (size_t limit = std::numeric_limits<DWORD>::max(); size > limit; ) {
    if (ReadFile(fileHandle, dest, static_cast<DWORD>(limit), &justRead, nullptr)) {
      dest += justRead;
      size -= justRead;
      bytesRead += justRead;
    }
    else {
      LOG_ERROR(logger, "read(): Failed to read FileHandle %p. Error: %d.", fileHandle, GetLastError());
      return false;
    }
  }
  if (size) {
    if (ReadFile(fileHandle, dest, static_cast<DWORD>(size), &justRead, nullptr)) {
      bytesRead += justRead;
    }
    else {
      LOG_ERROR(logger, "read(): Failed to read FileHandle %p. Error: %d.", fileHandle, GetLastError());
      return false;
    }
  }
  return true;
}
 
void* Cogs::FileHandle::map(ProtectionMode /*protectionMode*/, size_t offset, size_t size) {
  if (fileHandle == INVALID_HANDLE_VALUE) {
    LOG_ERROR(logger, "Cannot map invalid file handle.");
    return nullptr;
  }
 
  if (mapHandle) {
    LOG_ERROR(logger, "File handle cannot be mapped multiple times.");
    return nullptr;
  }
  
  DWORD maximumSize = (DWORD)(offset + size);
  DWORD maxHigh = (DWORD)((offset + size) >> 32);
 
  mapHandle = ::CreateFileMapping(fileHandle, nullptr, PAGE_READONLY, maxHigh, maximumSize, nullptr);
 
  if (!mapHandle) {
    LOG_ERROR(logger, "map(): CreateFileMapping failed. Last error: %d", GetLastError());
    return nullptr;
  }
 
  mappedMemory = ::MapViewOfFile(mapHandle, FILE_MAP_READ, 0, static_cast<DWORD>(offset), size);
 
  if (!mappedMemory) {
    LOG_ERROR(logger, "map(): MapViewOfFile failed. Last error: %d", GetLastError());
    return nullptr;
  }
 
  return mappedMemory;
}
 
void Cogs::FileHandle::unmap() {
  if (!mappedMemory) {
    LOG_WARNING(logger, "Cannot unmap file without mapped memory address (file mapping may have failed).");
    return;
  }
 
  ::UnmapViewOfFile(mappedMemory);
  mappedMemory = nullptr;
 
  ::CloseHandle(mapHandle);
  mapHandle = nullptr;
}