Automata-OO/FSM-OO/test1.cpp

#include <iostream>
#include <string>
#include <mutex>

#include "automata.h"
#include "state.h"

using namespace L87;

class S1 : public State {
public:
	S1(StateDiagram* parent) : State(parent) { _register(); }
	const char* name() override { return "S1"; }
	virtual State* next(char input) override {
		if (input == 'a') {
			return states["S2"];
		}
		if (input == 'b') {
			return this; // states["S1"];
		}
		return states["E"];
	}
};

class S2 : public State {
public:
	S2(StateDiagram* parent) : State(parent) { _register(); }
	virtual const char* name() override { return "S2"; }
	virtual State* next(char input) override {
		if (input == 'a') {
			return states["S3"];
		}
		if (input == 'b') {
			return states["T"];
		}
		return states["E"];
	}
};

class S3 : public State {
public:
	S3(StateDiagram* parent) : State(parent) { _register(); }
	virtual const char* name() override { return "S3"; }
	virtual State* next(char input) override {
		if (input == 'a') {
			return states["S1"];
		}
		return states["E"];
	}
};

class T : public State {
public:
	T(StateDiagram* parent) : State(parent) { _register(); }
	virtual const char* name() override { return "T"; }
	virtual State* next(char input) override {
		return this; // states["T"];
	}
	virtual bool done() override { return true; }
};

class E : public State {
public:
	E(StateDiagram* parent) : State(parent) { _register(); }
	virtual const char* name() override { return "E"; }
	virtual State* next(char input) override {
		return this; // states["E"];
	}
	virtual bool done() override { return true; }
	virtual bool bad() override { return true; }
};

class TestStateDiagram : public StateDiagram {
private:
	static TestStateDiagram* instance;
private:
	TestStateDiagram() {
		initial = new S1(this);
		new S2(this);
		new S3(this);
		new T(this);
		new E(this);
	}

	~TestStateDiagram() {
		for (auto it : states) {
			delete it.second;
		}
	}
public:
	static TestStateDiagram& Instance() {
		if (instance == nullptr) {
			if (instance == nullptr) {
				instance = new TestStateDiagram();
			}
		}
		return *instance;
	}
};
TestStateDiagram* TestStateDiagram::instance = nullptr;

int test1() {
	Automata automata(TestStateDiagram::Instance());
	{
		std::string input = "aaaab";
		Automata::Result result = automata.Run(input);
		std::string str((char*)result.value);
		std::cout << input << ':' << str << std::endl;
	}
	{
		std::string input = "aaaaaaaaaaaaaaaab";
		Automata::Result result = automata.Run(input);
		std::string str((char*)result.value);
		std::cout << input << ':' << str << std::endl;
	}
	return 0;
}