WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/Atom/VM/virtualmachine.cpp

     myGlobal->Set(String::New("stopIntervalThread"), FunctionTemplate::New(VirtualMachine::_stopIntervalThread));
     myGlobal->Set(String::New("startSocketThread"), FunctionTemplate::New(VirtualMachine::_startSocketThread));
     myGlobal->Set(String::New("stopSocketThread"), FunctionTemplate::New(VirtualMachine::_stopSocketThread));
     myGlobal->Set(String::New("sendToSocketThread"), FunctionTemplate::New(VirtualMachine::_sendToSocketThread));
     myGlobal->Set(String::New("uint2hex"), FunctionTemplate::New(VirtualMachine::_uint2hex));
+    myGlobal->Set(String::New("loadDataStore"), FunctionTemplate::New(VirtualMachine::_loadDataStore));
     myContext = Context::New(NULL, myGlobal);
     if (loadScript("System/Base.js"))
+    {
         result += underline + "\n";
+    }
     return result;
+}
+bool VirtualMachine::loadDataStore(string storeName)
+{
+    SyslogStream &slog = SyslogStream::getInstance();
+    string basePath = Settings::get("BasePath") + "Services/DataStores/";
+    string scriptFileName = basePath + storeName + ".js";
+    if (!file_exists(scriptFileName))
+    {
+        slog << "Failed to load datastore " + scriptFileName + ", file does not exist.\n";
+        return false;
+    }
+    string scriptSource = file_get_contents(scriptFileName);
+    scriptSource = "DataStore.addStore('" + storeName + "', " + str_replace("\n", "", scriptSource) + ");";
+    Handle<String> source =  String::New(scriptSource.c_str(), scriptSource.length());
+    Handle<String> name = String::New(scriptFileName.c_str(), scriptFileName.length());
+    Context::Scope contextScope(myContext);
+    TryCatch tryCatch;
+    Handle<Script> script = Script::Compile(source, name);
+    if (script.IsEmpty())
+    {
+        slog << formatException(&tryCatch);
+        return false;
+    }
+    else
+    {
+        Handle<Value> result = script->Run();
+        if (result.IsEmpty())
+        {
+            slog << formatException(&tryCatch);
+            return false;
+        }
+        slog << "Loaded datastore " + storeName + "\n";
+    }
+    return true;
+}
 bool VirtualMachine::loadScript(string scriptName)
+{
     SyslogStream &slog = SyslogStream::getInstance();
     return socketThread->getId();
+}
 bool VirtualMachine::stopSocketThread(unsigned int id)
 {
     if (mySocketThreads.find(id) != mySocketThreads.end())
     {
         delete mySocketThreads[id];
         mySocketThreads.erase(id);
         return true;
     }
     return false;
+}
 void VirtualMachine::sendToSocketThread(unsigned int id, string data)
 {
     if (mySocketThreads.find(id) != mySocketThreads.end())
+    {
         mySocketThreads[id]->send(data);
     }
 }
 void VirtualMachine::disconnectCommandClient(unsigned int id)
+{
     myCommandThread.disconnectClient(id);
 }
 void VirtualMachine::sendToCommandClient(unsigned int id, string data)
+{
     myCommandThread.sendTo(id, data);
 }
 void VirtualMachine::print(unsigned int id, string data)
+{
     if (id == 0)
     {
         SyslogStream &slog = SyslogStream::getInstance();
         slog << data;
+    }
     else
+    {
         VirtualMachine &vm = VirtualMachine::getInstance();
         vm.sendToCommandClient(id, data);
     }
 }
 bool VirtualMachine::runExpression(Expression expression)
+{
     string scriptName = "runExpression";
     string scriptData = expression.getScript();
     Handle<String> name = String::New(scriptName.c_str(), scriptName.length());
     Context::Scope contextScope(myContext);
     TryCatch tryCatch;
     Handle<Script> script = Script::Compile(source, name);
     if (script.IsEmpty())
     {
         print(expression.getTargetId(), formatException(&tryCatch));
         return false;
+    }
     else
+    {
         Handle<Value> result = script->Run();
                 print(expression.getTargetId(), resultString + "\n");
+             }
+        }
+    }
     return true;
 }
 Handle<Value> VirtualMachine::_quit(const Arguments& args)
 {
     VirtualMachine &vm = VirtualMachine::getInstance();
     vm.disconnectCommandClient(args[0]->Uint32Value());
     return Undefined();
+}
 Handle<Value> VirtualMachine::_log(const Arguments& args)
+{
     SyslogStream &slog = SyslogStream::getInstance();
     String::AsciiValue str(args[0]);
     slog << *str;
     return Undefined();
 }
 Handle<Value> VirtualMachine::_print(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
     String::AsciiValue str(args[1]);
     vm.print(args[0]->Uint32Value(), *str);
     return Undefined();
+}
 Handle<Value> VirtualMachine::_sendCanMessage(const Arguments& args)
 {
     CanNetManager &canMan = CanNetManager::getInstance();
     CanMessage canMessage;
     String::AsciiValue className(args[0]);
     VirtualMachine &vm = VirtualMachine::getInstance();
     String::AsciiValue str(args[0]);
     return Boolean::New(vm.loadScript(*str));
+}
+Handle<Value> VirtualMachine::_loadDataStore(const Arguments& args)
+{
+    VirtualMachine &vm = VirtualMachine::getInstance();
+    String::AsciiValue str(args[0]);
+    return Boolean::New(vm.loadDataStore(*str));
+}
 Handle<Value> VirtualMachine::_startIntervalThread(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
     return Integer::New(vm.startIntervalThread(args[0]->Uint32Value()));
+}
 Handle<Value> VirtualMachine::_stopIntervalThread(const Arguments& args)
 {
     VirtualMachine &vm = VirtualMachine::getInstance();
     return Boolean::New(vm.stopIntervalThread(args[0]->Uint32Value()));
+}
 Handle<Value> VirtualMachine::_startSocketThread(const Arguments& args)
 {
     VirtualMachine &vm = VirtualMachine::getInstance();
     String::AsciiValue address(args[0]);
     return Integer::New(vm.startSocketThread(*address, args[1]->Uint32Value(), args[2]->Uint32Value()));
+}
 Handle<Value> VirtualMachine::_stopSocketThread(const Arguments& args)
 {
     VirtualMachine &vm = VirtualMachine::getInstance();
     return Boolean::New(vm.stopSocketThread(args[0]->Uint32Value()));
 }
 Handle<Value> VirtualMachine::_sendToSocketThread(const Arguments& args)
 {
     VirtualMachine &vm = VirtualMachine::getInstance();
     String::AsciiValue data(args[1]);
     vm.sendToSocketThread(args[0]->Uint32Value(), *data);
     return Undefined();
 }
 Handle<Value> VirtualMachine::_uint2hex(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
     string hexId = uint2hex(args[0]->Uint32Value(), args[1]->Uint32Value());
     return String::New(hexId.c_str());
+}

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom/VM/virtualmachine.cpp – Rev 999 → 1007