Issue 5183 - Provide async interface for FileSystem

src/DefaultFileSystem.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2017 eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 57 matching lines @@
 
 std::shared_ptr<std::istream>
 DefaultFileSystem::Read(const std::string& path) const
 {
   std::shared_ptr<std::istream> result(new std::ifstream(NormalizePath(path).c_str()));
   if (result->fail())
     throw RuntimeErrorWithErrno("Failed to open " + path);
   return result;
 }
 
+void DefaultFileSystem::Read(const std::string& path,
+                             const ReadCallback& callback) const
+{
+  try
+  {
+    auto result = Read(path);
+    callback(result);
+  }
+  catch (...)
+  {
+  }
+}
+
 void DefaultFileSystem::Write(const std::string& path,
                               std::istream& data)
 {
   std::ofstream file(NormalizePath(path).c_str(), std::ios_base::out | std::ios_base::binary);
   file << Utils::Slurp(data);
 }
 
+void DefaultFileSystem::Write(const std::string& path,
+                              std::istream& data,
+                              const Callback& callback)
+{
+  Write(path, data);
+  callback();
+}
+
 void DefaultFileSystem::Move(const std::string& fromPath,
                              const std::string& toPath)
 {
   if (rename(NormalizePath(fromPath).c_str(), NormalizePath(toPath).c_str()))
     throw RuntimeErrorWithErrno("Failed to move " + fromPath + " to " + toPath);
 }
 
+void DefaultFileSystem::Move(const std::string& fromPath,
+                             const std::string& toPath,
+                             const Callback& callback)
+{
+  try
+  {
+    Move(fromPath, toPath);
+    callback();
+  }
+  catch (...)
+  {
+  }
+}
+
 void DefaultFileSystem::Remove(const std::string& path)
 {
   if (remove(NormalizePath(path).c_str()))
     throw RuntimeErrorWithErrno("Failed to remove " + path);
 }
 
+void DefaultFileSystem::Remove(const std::string& path,
+                               const Callback& callback)
+{
+  try
+  {
+    Remove(path);
+    callback();
+  }
+  catch (...)
+  {
+  }
+}
+
 FileSystem::StatResult DefaultFileSystem::Stat(const std::string& path) const
 {
   FileSystem::StatResult result;
 #ifdef WIN32
   WIN32_FILE_ATTRIBUTE_DATA data;
   if (!GetFileAttributesExW(NormalizePath(path).c_str(), GetFileExInfoStandard, &data))
   {
     DWORD err = GetLastError();
     if (err == ERROR_FILE_NOT_FOUND ||
         err == ERROR_PATH_NOT_FOUND ||
@@ skipping 46 matching lines @@
 #if _POSIX_C_SOURCE >= 200809L
   result.lastModified = static_cast<int64_t>(nativeStat.st_mtim.tv_sec) * MSEC_IN_SEC
                       +  static_cast<int64_t>(nativeStat.st_mtim.tv_nsec) / NSEC_IN_MSEC;
 #else
   result.lastModified = static_cast<int64_t>(nativeStat.st_mtime) * MSEC_IN_SEC;
 #endif
   return result;
 #endif
 }
 
+void DefaultFileSystem::Stat(const std::string& path,
+                             const StatCallback& callback) const
+{
+  try
+  {
+    auto stats = Stat(path);
+    callback(stats);
+  }
+  catch (...)
+  {
+  }
+}
+
 std::string DefaultFileSystem::Resolve(const std::string& path) const
 {
   if (basePath == "")
   {
     return path;
   }
   else
   {
 #ifdef _WIN32
   if (PathIsRelative(NormalizePath(path).c_str()))
 #else
   if (path.length() && *path.begin() != PATH_SEPARATOR)
 #endif
     {
       return basePath + PATH_SEPARATOR + path;
     }
     else
     {
       return path;
     }
   }
 }
+void DefaultFileSystem::Resolve(const std::string& path,
+                                const ResolveCallback& callback) const
+{
+  callback(Resolve(path));
+}
 
 void DefaultFileSystem::SetBasePath(const std::string& path)
 {
   basePath = path;
 
   if (*basePath.rbegin() == PATH_SEPARATOR)
   {
     basePath.resize(basePath.size() - 1);
   }
 }