DefaultIOHandler.cpp

#include "DefaultIOHandler.h"
 
#include <fstream>
#include <string>
#include <regex>
 
#ifndef EMSCRIPTEN
#include <filesystem>
 
namespace sys = std::filesystem;
#endif
 
namespace
{
  void autoExpandEnvironmentVariables(std::string & text)
  {
    static std::regex env("%([0-9A-Za-z\\/]*)%");
    std::smatch match;
    while (std::regex_search(text, match, env)) {
      const char * s = std::getenv(match[1].str().c_str());
      const std::string var(s == nullptr ? "" : s);
      text.replace(match[0].first, match[0].second, var);
    }
  }
 
  std::string expandEnvironmentVariables(const std::string & input) 
  {
    std::string text = input;
    autoExpandEnvironmentVariables(text);
    return text;
  }
 
  std::string getPath(Cogs::IIOHandler::FileType type, const std::string & fileName)
  {
    if (type == Cogs::IIOHandler::FileType::ShaderCache) {
      std::string path = std::string("%LOCALAPPDATA%") + "\\Kongsberg Digital\\Cogs.Rendering\\ShaderCache\\" + fileName;
      return expandEnvironmentVariables(path);
    }
 
    return{};
  }
}
 
bool Cogs::DefaultIOHandler::openFile(const StringView & fileName, std::string & content)
{
  return resolveFile("", fileName, content);
}
 
bool Cogs::DefaultIOHandler::resolveFile(const StringView & /*source*/, const StringView & fileName, std::string & content)
{
  std::ifstream file;
 
  for (auto & searchPath : searchPaths) {
    const auto & path = searchPath.size() ? searchPath + std::string(fileName) : std::string(fileName);
    
    file.open(path, std::ios::in);
 
    if (file.is_open()) break;
  }
  if (!file.is_open()) {
    fprintf(stderr, "Failed to load \"%.*s\"\n", StringViewFormat(fileName));
    return false;
  }
 
  file.seekg(0, std::ios::end);
 
  const auto fileSize = file.tellg();
 
  if (!fileSize) {
    return false;
  }
 
  content.resize(content.size() + fileSize, ' ');
 
  file.seekg(0, std::ios::beg);
 
  file.read(&content[0], fileSize);
 
  file.close();
 
  return true; 
}
 
void Cogs::DefaultIOHandler::addSearchPath(const StringView & path)
{
  searchPaths.push_back(std::string(path));
}
 
void Cogs::DefaultIOHandler::pushSearchPaths()
{
  pushedSearchPaths = searchPaths;
}
 
void Cogs::DefaultIOHandler::popSearchPaths()
{
  searchPaths = std::move(pushedSearchPaths);
}
 
bool Cogs::DefaultIOHandler::exists(FileType type, const StringView & fileName)
{
#ifndef EMSCRIPTEN
  sys::path path(getPath(type, std::string(fileName)));
 
  return sys::exists(path);
#else
  (void)type;
  (void)fileName;
  return false;
#endif
}
 
bool Cogs::DefaultIOHandler::writeBinaryFile(FileType type, const StringView & fileName, const void * content, size_t contentSize)
{
#ifndef EMSCRIPTEN
  sys::path path(getPath(type, std::string(fileName)));
  sys::create_directories(path.parent_path());
 
  std::fstream file(path.string(), std::ios::binary | std::ios::out);
 
  file.seekg(0, std::ios::beg);
 
  file.write((const char *)content, contentSize);
 
  file.close();
 
  return true;
#else
  (void)type;
  (void)fileName;
  (void)content;
  (void)contentSize;
  return false;
#endif
}
 
bool Cogs::DefaultIOHandler::openBinaryFile(FileType type, const StringView & fileName, std::vector<uint8_t> & content)
{
  std::fstream file(getPath(type, std::string(fileName)), std::ios::binary | std::ios::in);
 
  if (!file.is_open()) return false;
 
  file.seekg(0, std::ios::end);
 
  const auto fileSize = file.tellg();
 
  if (!fileSize) {
    return false;
  }
 
  content.resize(content.size() + fileSize, ' ');
 
  file.seekg(0, std::ios::beg);
 
  file.read((char *)content.data(), fileSize);
 
  file.close();
 
  return true;
}