* Session serialize/deserialize has an optional parameter 'from_registry'. It set, the FSM serialization will serialize

FSM's name instead of the automata definition, and deserialization, will get the automata fro the registry instead the
embedded definition.
* Ended session's don't have their stack emptied. It is necessary to get end state's name when `current_state_name`
is called.
* Finished session don't remove `state` info. Necessary to make `currentStateName` and `currentState` to give information
about the last state before getting session finished.

Author: hyperandroid

build/src/automata.d.ts

@@ -38,7 +38,7 @@ export declare class SessionConsumeMessagePromise<T> {
 export declare class FSMRegistry {
     static _fsm: GenericMap<FSM>;
     static FSMFromId(id: string): FSM;
-    static register(fsm_json: FSMJson): void;
+    static register(fsm_json: FSMJson): FSM;
     static createSession<T>(session_controller: T, fsm_id: string, o?: SessionObserver<T>): SessionConsumeMessagePromise<T>;
 }
 export interface StateAutoTransitionElement {
@@ -124,7 +124,7 @@ export interface SerializedSession {
     ended: boolean;
     controller: any;
     states: SerializedSessionContext[];
-    fsm: FSMJson;
+    fsm: FSMJson | string;
 }
 export declare class Session<T> {
     _fsm: FSM;
@@ -137,9 +137,9 @@ export declare class Session<T> {
     constructor(session_controller: T);
     __initialize(fsm: FSM): SessionConsumeMessagePromise<T>;
     __serializeController(): any;
-    serialize(): SerializedSession;
-    static deserialize<T, U>(s: SerializedSession, deserializer: (sg: U) => T): Session<T>;
-    __deserialize(s: SerializedSession): void;
+    serialize(from_registry?: boolean): SerializedSession;
+    static deserialize<T, U>(s: SerializedSession, deserializer: (sg: U) => T, from_registry?: boolean): Session<T>;
+    __deserialize(s: SerializedSession, from_registry?: boolean): void;
     addObserver(o: SessionObserver<T>): void;
     /**
      * User side message.

build/src/automata.js

@@ -1,7 +1,20 @@
+06-16-2016 *3.0.4*
+------------------
+* Session serialize/deserialize has an optional parameter 'from_registry'. It set, the FSM serialization will serialize
+FSM's name instead of the automata definition, and deserialization, will get the automata fro the registry instead the
+embedded definition.
+* Ended session's don't have their stack emptied. It is necessary to get end state's name when `current_state_name`
+is called.
+
+06-08-2016 *3.0.3*
+------------------
+* Finished session don't remove `state` info. Necessary to make `currentStateName` and `currentState` to give information
+about the last state before getting session finished.
+
 06-08-2016 *3.0.2*
 ------------------
 
-`dispatchMessage` now notifies on `onError` callback if the session is finished. Previously it threw an error, making mandatory to wrap dispatchMessage methods with try/catch.
+* `dispatchMessage` now notifies on `onError` callback if the session is finished. Previously it threw an error, making mandatory to wrap dispatchMessage methods with try/catch.
 Error callbacks have been refactored to return an Error instead of string.
 
 

build/src/automata.js.map

@@ -1,6 +1,6 @@
 {
   "name": "automata",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "main": "./build/src/automata.js",
   "keywords": [
     "DFA",

build/test/test3.js

@@ -63,14 +63,19 @@ export class FSMRegistry {
         return FSMRegistry._fsm[id];
     }
 
-    static register( fsm_json : FSMJson ) {
+    static register( fsm_json : FSMJson ) : FSM {
+
+        let ret : FSM = null;
         try {
             let fsm = new FSM(fsm_json);
             FSMRegistry._fsm[fsm.name] = fsm;
             console.log("Registered Automata '"+fsm.name+"'");
+            ret=fsm;
         } catch( e ) {
             console.error(e);
         }
+
+        return ret;
     }
 
     static createSession<T>( session_controller : T, fsm_id : string, o? : SessionObserver<T> ) : SessionConsumeMessagePromise<T> {
@@ -408,7 +413,7 @@ export interface SerializedSession {
     ended : boolean,
     controller : any,
     states : SerializedSessionContext[],
-    fsm : FSMJson
+    fsm : FSMJson | string
 }
 
 export class Session<T> {
@@ -452,34 +457,44 @@ export class Session<T> {
         return {};
     }
 
-    serialize() : SerializedSession {
+    serialize( from_registry?:boolean ) : SerializedSession {
 
         const serializedController = this.__serializeController();
 
         return {
             ended :     this._ended,
-            fsm :       this._fsm.serialize(),
+            fsm :       from_registry ? this._fsm.name : this._fsm.serialize(),
             states :    this._states.map( st => st.serialize() ),
             controller: serializedController
         };
     }
 
-    static deserialize<T,U>( s : SerializedSession, deserializer : (sg : U) => T ) : Session<T> {
+    static deserialize<T,U>( s : SerializedSession, deserializer : (sg : U) => T, from_registry?:boolean ) : Session<T> {
 
         const controller : T = deserializer( s.controller );
         const session : Session<T> = new Session( controller );
-        session.__deserialize( s );
+        session.__deserialize( s, from_registry );
 
         return session;
     }
 
-    __deserialize( s : SerializedSession ) {
+    __deserialize( s : SerializedSession, from_registry?:boolean ) {
+
+        if ( !from_registry ) {
+            this._fsm = FSMRegistry.register(s.fsm as FSMJson);
+        } else {
+            if ( typeof s.fsm==='string' ) {
+                // try automata saved as string.
+                this._fsm = FSMRegistry.FSMFromId(s.fsm as string);
+            } else {
+                // if not, assume it was saved as fully serialized automata, but loading it was saved as automata name.
+                this._fsm = FSMRegistry.FSMFromId((s.fsm as FSMJson).name);
+            }
+        }
 
-        FSMRegistry.register( s.fsm );
-        this._fsm= FSMRegistry.FSMFromId( s.fsm.name );
         this._ended = s.ended;
         this._states = s.states.map( e => {
-            const c : State = e.current_state === s.fsm.name ?
+            const c : State = e.current_state === this._fsm.name ?
                 this._fsm :
                 this._fsm._states.filter( s => s._name===e.current_state )[0];
             const p : State = e.prev_state === "" ?
@@ -680,7 +695,7 @@ export class Session<T> {
             this.__setCurrentState(next, m);
 
             if (next.isFinal()) {
-                this.__popAllStates(m);
+                // this.__popAllStates(m);
                 this.__endSession(m);
             }
         }

build/test/test3.js.map

@@ -168,6 +168,10 @@ Automata.CreateSession(
         console.log("");
         console.log("Sent 'bc'");
         session.dispatchMessage( { msgId: "bc" } );
+        session.dispatchMessage( { msgId: "bc" } ).then(
+            () => {},
+            (session:Session<Controller>, err:Error) => {console.error( err.message )}
+        );
     }
 );