Implement File API

src/FileSystemJsObject.cpp

 #include <AdblockPlus/FileSystem.h>
 #include <stdexcept>
 #include <sstream>
 #include <vector>
 
 #include "FileSystemJsObject.h"
 #include "Utils.h"
 #include "Thread.h"
 #include "Utils.h"
 
@@ skipping 229 matching lines @@
 
   private:
     std::string path;
   };
 
   v8::Handle<v8::Value> ReadCallback(const v8::Arguments& arguments)
   {
     const v8::Handle<const v8::External> external =
       v8::Handle<const v8::External>::Cast(arguments.Data());
     FileSystem* const fileSystem = static_cast<FileSystem*>(external->Value());
-    if (!arguments.Length() == 2)

[Wladimir Palant, 2013/04/16 13:03:41]

Does this actually work? :)
arguments.Length() != 2

[Felix Dahlke, 2013/04/16 14:00:09]

lol, yeah it does, but it sure is weird :) Fixed it here and below.

[Wladimir Palant, 2013/04/16 14:10:13]

Weird operator precedence rules then...

+    if (arguments.Length() != 2)
       return v8::ThrowException(v8::String::New(
         "_fileSystem.read requires 2 parameters"));
     const std::string path = Utils::FromV8String(arguments[0]);
     v8::Handle<v8::Value> callbackValue = arguments[1];
     if (!callbackValue->IsFunction())
       return v8::ThrowException(v8::String::New(
         "Second argument to _fileSystem.read must be a function"));
     v8::Handle<v8::Function> callback =
       v8::Handle<v8::Function>::Cast(callbackValue);
     ReadThread* const readThread = new ReadThread(*fileSystem, callback, path);
     readThread->Start();
     return v8::Undefined();
   }
 
   v8::Handle<v8::Value> WriteCallback(const v8::Arguments& arguments)
   {
     const v8::Handle<const v8::External> external =
       v8::Handle<const v8::External>::Cast(arguments.Data());
     FileSystem* const fileSystem = static_cast<FileSystem*>(external->Value());
-    if (!arguments.Length() == 3)
+    if (arguments.Length() != 3)
       return v8::ThrowException(v8::String::New(
         "_fileSystem.write requires 3 parameters"));
     const std::string path = Utils::FromV8String(arguments[0]);
     const std::string content = Utils::FromV8String(arguments[1]);
     v8::Handle<v8::Value> callbackValue = arguments[2];
     if (!callbackValue->IsFunction())
       return v8::ThrowException(v8::String::New(
         "Third argument to _fileSystem.write must be a function"));
     v8::Handle<v8::Function> callback =
       v8::Handle<v8::Function>::Cast(callbackValue);
     WriteThread* const writeThread = new WriteThread(*fileSystem, callback,
                                                      path, content);
     writeThread->Start();
     return v8::Undefined();
   }
 
   v8::Handle<v8::Value> MoveCallback(const v8::Arguments& arguments)
   {
     const v8::Handle<const v8::External> external =
       v8::Handle<const v8::External>::Cast(arguments.Data());
     FileSystem* const fileSystem = static_cast<FileSystem*>(external->Value());
-    if (!arguments.Length() == 3)
+    if (arguments.Length() != 3)
       return v8::ThrowException(v8::String::New(
         "_fileSystem.move requires 3 parameters"));
     const std::string fromPath = Utils::FromV8String(arguments[0]);
     const std::string toPath = Utils::FromV8String(arguments[1]);
     v8::Handle<v8::Value> callbackValue = arguments[2];
     if (!callbackValue->IsFunction())
       return v8::ThrowException(v8::String::New(
         "Third argument to _fileSystem.move must be a function"));
     v8::Handle<v8::Function> callback =
       v8::Handle<v8::Function>::Cast(callbackValue);
     MoveThread* const moveThread = new MoveThread(*fileSystem, callback,
                                                   fromPath, toPath);
     moveThread->Start();
     return v8::Undefined();
   }
 
   v8::Handle<v8::Value> RemoveCallback(const v8::Arguments& arguments)
   {
     const v8::Handle<const v8::External> external =
       v8::Handle<const v8::External>::Cast(arguments.Data());
     FileSystem* const fileSystem = static_cast<FileSystem*>(external->Value());
-    if (!arguments.Length() == 2)
+    if (arguments.Length() != 2)
       return v8::ThrowException(v8::String::New(
         "_fileSystem.remove requires 2 parameters"));
     const std::string path = Utils::FromV8String(arguments[0]);
     v8::Handle<v8::Value> callbackValue = arguments[1];
     if (!callbackValue->IsFunction())
       return v8::ThrowException(v8::String::New(
         "Second argument to _fileSystem.remove must be a function"));
     v8::Handle<v8::Function> callback =
       v8::Handle<v8::Function>::Cast(callbackValue);
     RemoveThread* const removeThread = new RemoveThread(*fileSystem, callback,
                                                         path);
     removeThread->Start();
     return v8::Undefined();
   }
 
   v8::Handle<v8::Value> StatCallback(const v8::Arguments& arguments)
   {
     const v8::Handle<const v8::External> external =
       v8::Handle<const v8::External>::Cast(arguments.Data());
     FileSystem* const fileSystem = static_cast<FileSystem*>(external->Value());
-    if (!arguments.Length() == 2)
+    if (arguments.Length() != 2)
       return v8::ThrowException(v8::String::New(
         "_fileSystem.stat requires 2 parameters"));
     const std::string path = Utils::FromV8String(arguments[0]);
     v8::Handle<v8::Value> callbackValue = arguments[1];
     if (!callbackValue->IsFunction())
       return v8::ThrowException(v8::String::New(
         "Second argument to _fileSystem.stat must be a function"));
     v8::Handle<v8::Function> callback =
       v8::Handle<v8::Function>::Cast(callbackValue);
     StatThread* const statThread = new StatThread(*fileSystem, callback, path);
@@ skipping 15 matching lines @@
   file->Set(v8::String::New("write"),
             v8::FunctionTemplate::New(WriteCallback, fileSystemExternal));
   file->Set(v8::String::New("move"),
             v8::FunctionTemplate::New(MoveCallback, fileSystemExternal));
   file->Set(v8::String::New("remove"),
             v8::FunctionTemplate::New(RemoveCallback, fileSystemExternal));
   file->Set(v8::String::New("stat"),
             v8::FunctionTemplate::New(StatCallback, fileSystemExternal));
   return handleScope.Close(file);
 }