Changeset 14560 for trunk/FACT++

Timestamp:

11/05/12 12:03:43 (12 years ago)

Author:

tbretz

Message:

Added the possibility to change the state of the state machine and define new states; renamed open to subscribe

Location:

trunk/FACT++/src

Files:

• InterpreterV8.cc (modified) (5 diffs)
• InterpreterV8.h (modified) (3 diffs)

trunk/FACT++/src/InterpreterV8.cc

@@ -87 +87 @@
     if (script.IsEmpty())
         return false;
+
+    JsSetState(3);
 
     const Handle<Value> result = script->Run();
@@ -319 +321 @@
 
     return handle_scope.Close(obj->NewInstance());
+}
+
+Handle<Value> InterpreterV8::FuncNewState(const Arguments& args)
+{
+    if (args.Length()<1 || args.Length()>3)
+        return ThrowException(String::New("Number of arguments must be 1, 2 or 3."));
+
+    if (!args[0]->IsUint32())
+        return ThrowException(String::New("Argument 1 must be an uint32."));
+    if (args.Length()>1 && !args[1]->IsString())
+        return ThrowException(String::New("Argument 2 must be a string."));
+    if (args.Length()>2 && !args[2]->IsString())
+        return ThrowException(String::New("Argument 3 must be a string."));
+
+    const HandleScope handle_scope;
+
+    const uint32_t index   = args[0]->Int32Value();
+    const string   name    = *String::Utf8Value(args[1]);
+    const string   comment = *String::Utf8Value(args[2]);
+
+    if (index<10 || index>255)
+        return ThrowException(String::New("State must be in the range [10, 255]."));
+
+    if (name.empty())
+        return ThrowException(String::New("State name must not be empty."));
+
+    if (name.find_first_of(':')!=string::npos || name.find_first_of('=')!=string::npos)
+        return ThrowException(String::New("State name must not contain : or =."));
+
+    if (JsHasState(index) || JsHasState(name))
+    {
+        const string what =
+            "State index ["+to_string(index)+"] or name ["+name+"] already defined.";
+
+        return ThrowException(String::New(what.c_str()));
+    }
+
+    return Boolean::New(JsNewState(index, name, comment));
+}
+
+Handle<Value> InterpreterV8::FuncSetState(const Arguments& args)
+{
+    if (args.Length()!=1)
+        return ThrowException(String::New("Number of arguments must be exactly 1."));
+
+    if (!args[0]->IsUint32() && !args[0]->IsString())
+        return ThrowException(String::New("Argument must be an unint32 or a  string."));
+
+    const HandleScope handle_scope;
+
+    int index = -2;
+    if (args[0]->IsUint32())
+    {
+        index = args[0]->Int32Value();
+    }
+    else
+    {
+        const string name = *String::Utf8Value(args[0]);
+        index = JsGetState(name);
+        if (index==-2)
+            return ThrowException(String::New(("State '"+name+"' not found.").c_str()));
+    }
+
+    if (index<10 || index>255)
+        return ThrowException(String::New("State must be in the range [10, 255]."));
+
+    return Boolean::New(JsSetState(index));
 }
 
@@ -838 +907 @@
 }
 
-Handle<Value> InterpreterV8::OnChangeSet(Local<String> prop, Local< Value > value, const AccessorInfo &info)
+Handle<Value> InterpreterV8::OnChangeSet(Local<String> prop, Local< Value > value, const AccessorInfo &)
 {
     const HandleScope handle_scope;
@@ -927 +996 @@
 }*/
 
-Handle<Value> InterpreterV8::FuncOpen(const Arguments &args)
+Handle<Value> InterpreterV8::FuncSubscribe(const Arguments &args)
 {
     if (args.Length()!=1)
@@ -977 +1046 @@
     // Create a template for the global object.
     Handle<ObjectTemplate> dim = ObjectTemplate::New();
-    dim->Set(String::New("print"),    FunctionTemplate::New(WrapPrint),    ReadOnly);
-    dim->Set(String::New("alarm"),    FunctionTemplate::New(WrapAlarm),    ReadOnly);
-    dim->Set(String::New("out"),      FunctionTemplate::New(WrapOut),      ReadOnly);
-    dim->Set(String::New("wait"),     FunctionTemplate::New(WrapWait),     ReadOnly);
-    dim->Set(String::New("send"),     FunctionTemplate::New(WrapSend),     ReadOnly);
-    dim->Set(String::New("state"),    FunctionTemplate::New(WrapState),    ReadOnly);
-    dim->Set(String::New("sleep"),    FunctionTemplate::New(WrapSleep),    ReadOnly);
-    dim->Set(String::New("open"),     FunctionTemplate::New(WrapOpen),     ReadOnly);
-    dim->Set(String::New("database"), FunctionTemplate::New(WrapDatabase), ReadOnly);
+    dim->Set(String::New("print"),     FunctionTemplate::New(WrapPrint),     ReadOnly);
+    dim->Set(String::New("alarm"),     FunctionTemplate::New(WrapAlarm),     ReadOnly);
+    dim->Set(String::New("out"),       FunctionTemplate::New(WrapOut),       ReadOnly);
+    dim->Set(String::New("wait"),      FunctionTemplate::New(WrapWait),      ReadOnly);
+    dim->Set(String::New("send"),      FunctionTemplate::New(WrapSend),      ReadOnly);
+    dim->Set(String::New("state"),     FunctionTemplate::New(WrapState),     ReadOnly);
+    dim->Set(String::New("newState"),  FunctionTemplate::New(WrapNewState),  ReadOnly);
+    dim->Set(String::New("setState"),  FunctionTemplate::New(WrapSetState),  ReadOnly);
+    dim->Set(String::New("sleep"),     FunctionTemplate::New(WrapSleep),     ReadOnly);
+    dim->Set(String::New("subscribe"), FunctionTemplate::New(WrapSubscribe), ReadOnly);
+    dim->Set(String::New("database"),  FunctionTemplate::New(WrapDatabase),  ReadOnly);
 
     Handle<ObjectTemplate> onchange = ObjectTemplate::New();

trunk/FACT++/src/InterpreterV8.h

@@ -53 +53 @@
     v8::Handle<v8::Value> FuncExit(const v8::Arguments& args);
     v8::Handle<v8::Value> FuncState(const v8::Arguments& args);
-    v8::Handle<v8::Value> FuncOpen(const v8::Arguments& args);
+    v8::Handle<v8::Value> FuncSetState(const v8::Arguments& args);
+    v8::Handle<v8::Value> FuncNewState(const v8::Arguments& args);
+    //v8::Handle<v8::Value> FuncOpen(const v8::Arguments& args);
+    v8::Handle<v8::Value> FuncSubscribe(const v8::Arguments& args);
     v8::Handle<v8::Value> FuncGetData(const v8::Arguments &args);
     v8::Handle<v8::Value> FuncClose(const v8::Arguments &args);
@@ -72 +75 @@
     static v8::Handle<v8::Value> WrapExit(const v8::Arguments &args)     { if (This) return This->FuncExit(args);     else return v8::Undefined(); }
     static v8::Handle<v8::Value> WrapState(const v8::Arguments &args)    { if (This) return This->FuncState(args);    else return v8::Undefined(); }
-    static v8::Handle<v8::Value> WrapOpen(const v8::Arguments &args)     { if (This) return This->FuncOpen(args);     else return v8::Undefined(); }
+    static v8::Handle<v8::Value> WrapNewState(const v8::Arguments &args) { if (This) return This->FuncNewState(args); else return v8::Undefined(); }
+    static v8::Handle<v8::Value> WrapSetState(const v8::Arguments &args) { if (This) return This->FuncSetState(args); else return v8::Undefined(); }
+    //static v8::Handle<v8::Value> WrapOpen(const v8::Arguments &args)     { if (This) return This->FuncOpen(args);     else return v8::Undefined(); }
+    static v8::Handle<v8::Value> WrapSubscribe(const v8::Arguments &args){ if (This) return This->FuncSubscribe(args);else return v8::Undefined(); }
     static v8::Handle<v8::Value> WrapGetData(const v8::Arguments &args)  { if (This) return This->FuncGetData(args);  else return v8::Undefined(); }
     static v8::Handle<v8::Value> WrapClose(const v8::Arguments &args)    { if (This) return This->FuncClose(args);    else return v8::Undefined(); }
@@ -122 +128 @@
     virtual void *JsSubscribe(const std::string &) { return 0; };
     virtual bool  JsUnsubscribe(const std::string &) { return false; };
+
+    virtual bool JsNewState(int, const std::string&, const std::string&) { return false; }
+    virtual bool JsSetState(int) { return false; }
+    virtual bool JsHasState(int) const { return false; }
+    virtual bool JsHasState(const std::string &) const { return false; }
+    virtual int  JsGetState(const std::string &) const { return -2; }
+
     virtual std::vector<Description> JsDescription(const std::string &) { return std::vector<Description>(); };
     virtual std::pair<uint64_t, EventImp *> JsGetEvent(const std::string &) { return std::make_pair(0, (EventImp*)0); };