1 files changed, 93 insertions, 85 deletions

diff --git a/src/uscxml/interpreter/LargeMicroStep.h b/src/uscxml/interpreter/LargeMicroStep.h
index 0d7d467..35e21de 100644
--- a/src/uscxml/interpreter/LargeMicroStep.h
+++ b/src/uscxml/interpreter/LargeMicroStep.h
@@ -58,7 +58,9 @@ public:
 	virtual ~LargeMicroStep();
 	virtual std::shared_ptr<MicroStepImpl> create(MicroStepCallbacks* callbacks);
 
-    std::string getName() { return "large"; }
+	std::string getName() {
+		return "large";
+	}
 
 	virtual InterpreterState step(size_t blockMs);
 	virtual void reset();
@@ -66,46 +68,51 @@ public:
 	virtual std::list<XERCESC_NS::DOMElement*> getConfiguration();
 	void markAsCancelled();
 
-    virtual void deserialize(const Data& encodedState) {}
-    virtual Data serialize() { return Data(); }
+	virtual void deserialize(const Data& encodedState) {}
+	virtual Data serialize() {
+		return Data();
+	}
 
 protected:
-    LargeMicroStep() {} // only for the factory
-    
+	LargeMicroStep() {} // only for the factory
+
 	class State;
 	class Transition;
 
-    struct StateOrder
-    {
-        bool operator()(const State* lhs, const State* rhs) const  { return lhs->documentOrder < rhs->documentOrder; }
-    };
-    struct StateOrderPostFix
-    {
-        bool operator()(const State* lhs, const State* rhs) const  { return lhs->postFixOrder < rhs->postFixOrder; }
-    };
-
-    struct TransitionOrder
-    {
-        bool operator()(const Transition* lhs, const Transition* rhs) const  { return lhs->postFixOrder < rhs->postFixOrder; }
-    };
-
-    std::vector<State*> _states; ///< States in document order
-    std::vector<Transition*> _transitions; ///< Transitions in reverse post-order
-
-    boost::container::flat_set<State*, StateOrder> _configuration;
-    boost::container::flat_set<State*, StateOrderPostFix> _configurationPostFix;
-    boost::container::flat_set<State*, StateOrder> _invocations;
-    boost::container::flat_set<State*, StateOrder> _history;
-    boost::container::flat_set<State*, StateOrder> _initializedData;
+	struct StateOrder {
+		bool operator()(const State* lhs, const State* rhs) const  {
+			return lhs->documentOrder < rhs->documentOrder;
+		}
+	};
+	struct StateOrderPostFix {
+		bool operator()(const State* lhs, const State* rhs) const  {
+			return lhs->postFixOrder < rhs->postFixOrder;
+		}
+	};
+
+	struct TransitionOrder {
+		bool operator()(const Transition* lhs, const Transition* rhs) const  {
+			return lhs->postFixOrder < rhs->postFixOrder;
+		}
+	};
+
+	std::vector<State*> _states; ///< States in document order
+	std::vector<Transition*> _transitions; ///< Transitions in reverse post-order
+
+	boost::container::flat_set<State*, StateOrder> _configuration;
+	boost::container::flat_set<State*, StateOrderPostFix> _configurationPostFix;
+	boost::container::flat_set<State*, StateOrder> _invocations;
+	boost::container::flat_set<State*, StateOrder> _history;
+	boost::container::flat_set<State*, StateOrder> _initializedData;
 
 	class Transition {
 	public:
-        Transition(uint32_t postFixOrder) : postFixOrder(postFixOrder) {}
-        const uint32_t postFixOrder; // making these const increases performance somewhat
+		Transition(uint32_t postFixOrder) : postFixOrder(postFixOrder) {}
+		const uint32_t postFixOrder; // making these const increases performance somewhat
 
 		XERCESC_NS::DOMElement* element = NULL;
-        boost::container::flat_set<uint32_t> compatible;
-        boost::container::flat_set<uint32_t> conflicting;
+		boost::container::flat_set<uint32_t> compatible;
+		boost::container::flat_set<uint32_t> conflicting;
 		std::pair<uint32_t, uint32_t> exitSet;
 
 		State* source = NULL;
@@ -122,83 +129,84 @@ protected:
 
 	class State {
 	public:
-        State(uint32_t documentOrder) : documentOrder(documentOrder) {}
-        const uint32_t documentOrder;
-        uint32_t postFixOrder;
+		State(uint32_t documentOrder) : documentOrder(documentOrder) {}
+		const uint32_t documentOrder;
+		uint32_t postFixOrder;
 
 		XERCESC_NS::DOMElement* element;
 		boost::container::flat_set<State*, StateOrder> completion;
-        boost::container::flat_set<State*, StateOrder> ancestors; // TODO: leverage!
+		boost::container::flat_set<State*, StateOrder> ancestors; // TODO: leverage!
 		std::vector<State*> children;
 		State* parent = NULL;
 
-        std::vector<Transition*> transitions;
+		std::vector<Transition*> transitions;
 		std::vector<XERCESC_NS::DOMElement*> data;
 		std::vector<XERCESC_NS::DOMElement*> invoke;
 		std::vector<XERCESC_NS::DOMElement*> onEntry;
 		std::vector<XERCESC_NS::DOMElement*> onExit;
 		XERCESC_NS::DOMElement* doneData = NULL;
+		std::string name;
 
 		unsigned char type;
 	};
 
-    void init(XERCESC_NS::DOMElement* scxml);
+	void init(XERCESC_NS::DOMElement* scxml);
+
+	std::list<XERCESC_NS::DOMElement*> getCompletion(const XERCESC_NS::DOMElement* state);
+	std::list<XERCESC_NS::DOMElement*> getHistoryCompletion(const XERCESC_NS::DOMElement* history);
 
-    std::list<XERCESC_NS::DOMElement*> getCompletion(const XERCESC_NS::DOMElement* state);
-    std::list<XERCESC_NS::DOMElement*> getHistoryCompletion(const XERCESC_NS::DOMElement* history);
+	unsigned char _flags = 0;
+	boost::container::flat_set<boost::container::flat_set<State*, StateOrder> > _microstepConfigurations;
 
-    unsigned char _flags = 0;
-    boost::container::flat_set<boost::container::flat_set<State*, StateOrder> > _microstepConfigurations;
+	bool _isInitialized = false;
+	bool _isCancelled = false;
+	Event _event; // we do not care about the event's representation
 
-    bool _isInitialized = false;
-    bool _isCancelled = false;
-    Event _event; // we do not care about the event's representation
+	std::list<XERCESC_NS::DOMElement*> _globalScripts;
 
-    std::list<XERCESC_NS::DOMElement*> _globalScripts;
+	Binding _binding;
+	XERCESC_NS::DOMElement* _scxml;
+	X _xmlPrefix;
+	X _xmlNS;
 
-    Binding _binding;
-    XERCESC_NS::DOMElement* _scxml;
-    X _xmlPrefix;
-    X _xmlNS;
-    
-    /// Normalize order of elements per state
-    void resortStates(XERCESC_NS::DOMElement* node, const X& xmlPrefix);
+	/// Normalize order of elements per state
+	void resortStates(XERCESC_NS::DOMElement* node, const X& xmlPrefix);
 
 private:
 
-    boost::container::flat_set<State*, StateOrder> _exitSet;
-    boost::container::flat_set<State*, StateOrder> _entrySet;
-    boost::container::flat_set<State*, StateOrder> _targetSet;
-    boost::container::flat_set<State*, StateOrder> _tmpStates;
-    
-    boost::dynamic_bitset<BITSET_BLOCKTYPE> _compatible;
-    boost::dynamic_bitset<BITSET_BLOCKTYPE> _conflicting;
-    
-    boost::container::flat_set<Transition*, TransitionOrder> _transSet;
-
-    // adapted from http://www.cplusplus.com/reference/algorithm/set_intersection/
-    template <class iter_t1, class iter_t2, class compare = StateOrder>
-    bool intersects(iter_t1 first1, iter_t1 last1, iter_t2 first2, iter_t2 last2) {
-        while (first1 != last1 && first2 != last2) {
-            if (compare()(*first1, *first2)) {
-                ++first1;
-            } else if (compare()(*first2, *first1)) {
-                ++first2;
-            } else {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    bool isInFinal(const State* state);
-    void printStateNames(const boost::container::flat_set<LargeMicroStep::State*, LargeMicroStep::StateOrder>& a);
-
-    uint32_t getTransitionDomain(const Transition* transition);
-    std::pair<uint32_t, uint32_t> getExitSet(const Transition* transition);
-    std::map<uint32_t, std::pair<uint32_t, uint32_t> > _exitSetCache;
-
-    friend class Factory;
+	boost::container::flat_set<State*, StateOrder> _exitSet;
+	boost::container::flat_set<State*, StateOrder> _entrySet;
+	boost::container::flat_set<State*, StateOrder> _targetSet;
+	boost::container::flat_set<State*, StateOrder> _tmpStates;
+
+	boost::dynamic_bitset<BITSET_BLOCKTYPE> _compatible;
+	boost::dynamic_bitset<BITSET_BLOCKTYPE> _conflicting;
+
+	boost::container::flat_set<Transition*, TransitionOrder> _transSet;
+
+	// adapted from http://www.cplusplus.com/reference/algorithm/set_intersection/
+	template <class iter_t1, class iter_t2, class compare = StateOrder>
+	bool intersects(iter_t1 first1, iter_t1 last1, iter_t2 first2, iter_t2 last2) {
+		while (first1 != last1 && first2 != last2) {
+			if (compare()(*first1, *first2)) {
+				++first1;
+			} else if (compare()(*first2, *first1)) {
+				++first2;
+			} else {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	bool isInFinal(const State* state);
+	void printStateNames(const boost::container::flat_set<LargeMicroStep::State*, LargeMicroStep::StateOrder>& a);
+
+	uint32_t getTransitionDomain(const Transition* transition);
+	std::pair<uint32_t, uint32_t> getExitSet(const Transition* transition);
+	std::map<uint32_t, std::pair<uint32_t, uint32_t> > _exitSetCache;
+
+	friend class Factory;
 };
 
 }