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

     myGlobal->Set(String::New("sendCanMessage"), FunctionTemplate::New(VirtualMachine::_sendCanMessage));
     myGlobal->Set(String::New("sendCanNMTMessage"), FunctionTemplate::New(VirtualMachine::_sendCanNMTMessage));
     myGlobal->Set(String::New("loadScript"), FunctionTemplate::New(VirtualMachine::_loadScript));
     myGlobal->Set(String::New("startIntervalThread"), FunctionTemplate::New(VirtualMachine::_startIntervalThread));
     myGlobal->Set(String::New("stopIntervalThread"), FunctionTemplate::New(VirtualMachine::_stopIntervalThread));
+    myGlobal->Set(String::New("setIntervalThreadTimeout"), FunctionTemplate::New(VirtualMachine::_setIntervalThreadTimeout));
     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("loadDataStore"), FunctionTemplate::New(VirtualMachine::_loadDataStore));
     myGlobal->Set(String::New("getFileContents"), FunctionTemplate::New(VirtualMachine::_getFileContents));
 bool VirtualMachine::stopIntervalThread(unsigned int id)
+{
     if (myIntervalThreads.find(id) != myIntervalThreads.end())
+    {
+        myIntervalThreads[id]->stop();
         delete myIntervalThreads[id];
         myIntervalThreads.erase(id);
         return true;
+    }
+    return false;
+}
+bool VirtualMachine::setIntervalThreadTimeout(unsigned int id, unsigned int timeout)
+{
+    if (myIntervalThreads.find(id) != myIntervalThreads.end())
+    {
+        myIntervalThreads[id]->setTimeout(timeout);
+        return true;
     }
     return false;
+}
 unsigned int VirtualMachine::startSocketThread(string address, int port, unsigned int reconnectTimeout)
 {
     SocketThread *socketThread = new SocketThread(address, port, reconnectTimeout);
     mySocketThreads[socketThread->getId()] = socketThread;
     mySocketThreads[socketThread->getId()]->start();
     return socketThread->getId();
 }
 bool VirtualMachine::stopSocketThread(unsigned int id)
+{
     if (mySocketThreads.find(id) != mySocketThreads.end())
+    {
         delete mySocketThreads[id];
     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)
     {
         Logger &log = Logger::getInstance();
         log.add(data);
+    }
     else
+    {
         VirtualMachine &vm = VirtualMachine::getInstance();
         vm.sendToCommandClient(id, data);
     }
 }
 bool VirtualMachine::runExpression(Expression expression)
+{
     string scriptName = "runExpression";
     else
+    {
         Handle<Value> result = script->Run();
         if (result.IsEmpty())
         {
             print(expression.getTargetId(), formatException(&tryCatch));
             return false;
+        }
         else if (expression.getTargetId() != 0)
         {
              String::AsciiValue ascii(result);
              string resultString = *ascii;
              if (resultString != "undefined")
              {
                 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)
+{
     Logger &log = Logger::getInstance();
     String::AsciiValue str(args[0]);
     log.add(*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]);
     canMessage.setClassName(*className);
     String::AsciiValue directionFlag(args[1]);
     canMessage.setDirectionFlag(*directionFlag);
     String::AsciiValue moduleName(args[2]);
     canMessage.setModuleName(*moduleName);
     canMessage.setData(data);
     canMan.sendMessage(canMessage);
     return Undefined();
 }
 Handle<Value> VirtualMachine::_loadScript(const Arguments& args)
 {
     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::_setIntervalThreadTimeout(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();
-    return Boolean::New(vm.stopIntervalThread(args[0]->Uint32Value()));
+    return Integer::New(vm.setIntervalThreadTimeout(args[0]->Uint32Value(), args[1]->Uint32Value()));
+}
 Handle<Value> VirtualMachine::_startSocketThread(const Arguments& args)
+{
     VirtualMachine &vm = VirtualMachine::getInstance();

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom/src/VM/virtualmachine.cpp @ 2124 – Rev 1026 → 1042