WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/Atom1.5/src/vm/Manager.cpp

         for (unsigned int n = 0; n < this->plugins_.size(); n++)
+        {
             if (this->plugins_[n]->GetName() == this->current_plugin_name_)
+            {
                 this->plugins_[n]->CallOutput(this->current_request_id_, output);
+                return;
+            }
+        }
+    }
+    else
+    {
+        LOG.Info(output);
+    }
+}
+void Manager::CallResult(std::string output)
+{
+  if (this->current_plugin_name_ != "")
+  {
+    for (unsigned int n = 0; n < this->plugins_.size(); n++)
+    {
+      if (this->plugins_[n]->GetName() == this->current_plugin_name_)
+      {
+        this->plugins_[n]->CallResult(this->current_request_id_, output);
-                return;
+        return;
+      }
+    }
+  }
-    else
+  else
     v8::Locker lock;
     v8::Context::Scope context_scope(Manager::Instance()->GetContext());
     v8::HandleScope handle_scope;
     //LOG.Debug(std::string(__FUNCTION__) + " called!");
     if (args.Length() < 1)
+    {
         Manager::instance_->LOG.Error(std::string(__FUNCTION__) + ": To few arguments to log.");
         return v8::Undefined();
     }
     v8::String::AsciiValue str(args[0]);
     Manager::instance_->CallOutput(*str);
     return handle_scope.Close(v8::Undefined());
+}
 void Manager::Call(std::string plugin_name, unsigned int request_id, std::string name, ArgumentListPointer arguments)
 {
     this->io_service_.post(boost::bind(&Manager::CallHandler, this, plugin_name, request_id, name, arguments));
+}
 void Manager::Execute(std::string plugin_name, unsigned int request_id, std::string code)
+{
     this->io_service_.post(boost::bind(&Manager::ExecuteHandler, this, plugin_name, request_id, code));
 }
 bool Manager::CallHandler(std::string plugin_name, unsigned int request_id, std::string name, ArgumentListPointer arguments)
+{
     v8::Locker lock;
     v8::Context::Scope context_scope(this->context_);
     this->current_request_id_ = request_id;
     if (this->functions_.find(name) == this->functions_.end())
+    {
         this->CallOutput("No such function found, " + name);
         this->current_plugin_name_ = "";
         this->current_request_id_ = 0;
         return false;
+    }
     //LOG.Debug("Call: " + name);
     Value result = this->functions_[name]->Call(this->context_->Global(), arguments->size(), arguments->data());
     if (result.IsEmpty())
     {
         this->CallOutput(this->FormatException(try_catch));
         this->current_plugin_name_ = "";
         this->current_request_id_ = 0;
         return false;
+    }
     //v8::String::AsciiValue response(result->ToString());
     //this->CallOutput(plugin_name, request_id, std::string(*response));
     v8::Locker lock;
     v8::HandleScope handle_scope;
     v8::Handle<v8::ObjectTemplate> raw_template = v8::ObjectTemplate::New();
     raw_template->Set(v8::String::New("Log"), v8::FunctionTemplate::New(Manager::Export_Log));
     for (unsigned int c = 0; c < this->plugins_.size(); c++)
+    {
         ExportFunctionList export_functions = this->plugins_[c]->GetExportFunctions();
         for (ExportFunctionList::iterator it = export_functions.begin(); it != export_functions.end(); it++)
+        {
             raw_template->Set(v8::String::New(it->first.data()), v8::FunctionTemplate::New(it->second));
         }
     }
     this->context_ = v8::Context::New(NULL, raw_template);
     v8::Context::Scope context_scope(this->context_);
     for (unsigned int c = 0; c < this->plugins_.size(); c++)
+    {
         this->LoadScript("plugin/" + this->plugins_[c]->GetName() + ".js");
     }
     this->object_template_ = v8::Persistent<v8::ObjectTemplate>::New(raw_template);
     for (unsigned int c = 0; c < this->plugins_.size(); c++)
+    {
         this->plugins_[c]->InitializeDone();
+    }
 }
 bool Manager::ImportFunction(std::string functionname)
+{
     v8::Locker lock;
     v8::Context::Scope context_scope(this->context_);
     v8::TryCatch try_catch;
     v8::Handle<v8::String> process_name = v8::String::New(functionname.data());
     v8::Handle<v8::Value> process_val = this->context_->Global()->Get(process_name);
     if (!process_val->IsFunction())
     {
         LOG.Error(functionname + " was not found to be a function!");
         return false;
+    }
     v8::Handle<v8::Function> process_fun = v8::Handle<v8::Function>::Cast(process_val);
     code += "\n";
     file.close();
     v8::Locker lock;
     v8::Context::Scope context_scope(this->context_);
     v8::TryCatch try_catch;
     v8::Handle<v8::Script> script = v8::Script::Compile(v8::String::New(code.data(), code.length()),
                                                         v8::String::New(scriptname.data(), scriptname.length()));
+        {
             this->CallOutput(this->FormatException(try_catch));
+        }
         else
+        {
-            //v8::String::AsciiValue response(result->ToString());
+            v8::String::AsciiValue response(result->ToString());
-            //this->CallOutput(std::string(*response));
+            this->CallResult(std::string(*response));
+        }
+    }
     this->current_plugin_name_ = "";
     this->current_request_id_ = 0;

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom1.5/src/vm/Manager.cpp @ 1663 – Rev 1741 → 2107