Implement File API

shell/src/Main.cpp

 #include <AdblockPlus.h>
 #include <fstream>
 #include <iostream>
 #include <sstream>
 
 #include "GcCommand.h"
 #include "HelpCommand.h"
 #include "FiltersCommand.h"
 #include "SubscriptionsCommand.h"
 #include "MatchesCommand.h"
 
 namespace
 {
-  class LibFileReader : public AdblockPlus::FileReader
+  class LibFileSystem : public AdblockPlus::FileSystem
   {
   public:
     std::auto_ptr<std::istream> Read(const std::string& path) const
     {
       std::ifstream* file = new std::ifstream;
       file->open(("lib/" + path).c_str());

[Wladimir Palant, 2013/04/12 16:10:35]

I don't think this dummy implementation is useful. We no longer load scripts
from the file system, if anything we should have a full-fetched implementation
here that would actually allow ABP to save data. But then it doesn't make sense
to keep the implementation private to the shell. How about a DefaultFileSystem
class that would work out of the box on platforms we support? It could take the
base directory as constructor parameter to make sure special scenarios are
considered properly (Android).

[Felix Dahlke, 2013/04/15 03:43:34]

Fair enough, will do that.

       return std::auto_ptr<std::istream>(file);
     }
+
+    void Write(const std::string& path, const std::string& content)
+    {
+      throw std::runtime_error("Write is not implemented");
+    }
+
+    void Move(const std::string& fromPath, const std::string& toPath)
+    {
+      throw std::runtime_error("Move is not implemented");
+    }
+
+    void Remove(const std::string& path)
+    {
+      throw std::runtime_error("Remove is not implemented");
+    }
+
+    StatResult Stat(const std::string& path) const
+    {
+      throw std::runtime_error("Stat is not implemented");
+    }
   };
 
   class CerrErrorCallback : public AdblockPlus::ErrorCallback
   {
   public:
     void operator()(const std::string& message)
     {
       std::cerr << "Error: " << message << std::endl;
     }
   };
@@ skipping 18 matching lines @@
     std::istringstream lineStream(commandLine);
     lineStream >> name;
     std::getline(lineStream, arguments);
   }
 }
 
 int main()
 {
   try
   {
-    LibFileReader fileReader;
+    LibFileSystem fileSystem;
     AdblockPlus::DefaultWebRequest webRequest;
     CerrErrorCallback errorCallback;
-    AdblockPlus::JsEngine jsEngine(&fileReader, &webRequest, &errorCallback);
+    AdblockPlus::JsEngine jsEngine(&fileSystem, &webRequest, &errorCallback);
     AdblockPlus::FilterEngine filterEngine(jsEngine);
 
     CommandMap commands;
     Add(commands, new GcCommand(jsEngine));
     Add(commands, new HelpCommand(commands));
     Add(commands, new FiltersCommand(filterEngine));
     Add(commands, new SubscriptionsCommand(filterEngine));
     Add(commands, new MatchesCommand(filterEngine));
 
     std::string commandLine;
@@ skipping 15 matching lines @@
         std::cout << error.what() << std::endl;
       }
     }
   }
   catch (const std::exception& e)
   {
     std::cerr << "Exception: " << e.what() << std::endl;
   }
   return 0;
 }