(#318) builder pattern implemented

libs/InputGenerator/include/InputGenerator/AutomatonGenerator.h

@@ -22,6 +22,86 @@ enum class FA_type {
 	DFA
 };
 
+class AutomatonGeneratorBuilder {
+public:
+    int initial_ = 0;
+    int states_number_ = 10;
+    int max_edges_number_ = 0;
+    int edges_number_ = 0;
+    int colors_ = 4;
+    int colors_tries_ = 10;
+    int terminal_probability_ = 20;
+    int epsilon_probability_ = 10;
+    int ref_probability_ = 50;
+    int seed_it_ = 0;
+    int memory_cells_number_ = 0;
+    std::vector<char> alphabet_;
+
+    AutomatonGeneratorBuilder& setInitial(int initial) {
+        initial_ = initial;
+        return *this;
+    }
+
+    AutomatonGeneratorBuilder& setStatesNumber(int states_number) {
+        states_number_ = states_number;
+        return *this;
+    }
+
+    AutomatonGeneratorBuilder& setMaxEdgesNumber(int max_edges_number) {
+        max_edges_number_ = max_edges_number;
+        return *this;
+    }
+
+    AutomatonGeneratorBuilder& setEdgesNumber(int edges_number) {
+        edges_number_ = edges_number;
+        return *this;
+    }
+
+    AutomatonGeneratorBuilder& setColors(int colors) {
+        colors_ = colors;
+        return *this;
+    }
+
+    AutomatonGeneratorBuilder& setColorsTries(int colors_tries) {
+        colors_tries_ = colors_tries;
+        return *this;
+    }
+
+    AutomatonGeneratorBuilder& setTerminalProbability(int terminal_probability) {
+        terminal_probability_ = terminal_probability;
+        return *this;
+    }
+
+    AutomatonGeneratorBuilder& setEpsilonProbability(int epsilon_probability) {
+        epsilon_probability_ = epsilon_probability;
+        return *this;
+    }
+
+    AutomatonGeneratorBuilder& setRefProbability(int ref_probability) {
+        ref_probability_ = ref_probability;
+        return *this;
+    }
+
+    AutomatonGeneratorBuilder& setSeedIt(int seed_it) {
+        seed_it_ = seed_it;
+        return *this;
+    }
+
+    AutomatonGeneratorBuilder& setMemoryCellsNumber(int memory_cells_number) {
+        memory_cells_number_ = memory_cells_number;
+        return *this;
+    }
+
+    AutomatonGeneratorBuilder& setAlphabet(const std::vector<char>& alphabet) {
+        alphabet_ = alphabet;
+        return *this;
+    }
+
+    AutomatonGenerator build() {
+        return AutomatonGenerator(*this);
+    }
+};
+
 class AutomatonGenerator {
   private:
 	struct FAtransition {
@@ -196,9 +276,67 @@ class AutomatonGenerator {
 	AutomatonGenerator(FA_type type = FA_type::NFA, int n = 10,
 					   const std::string& grammar_file = GrammarPath);
 
+    AutomatonGenerator(const AutomatonGeneratorBuilder& builder)
+        : initial(builder.initial_),
+          states_number(builder.states_number_),
+          max_edges_number(builder.max_edges_number_),
+          edges_number(builder.edges_number_),
+          colors(builder.colors_),
+          colors_tries(builder.colors_tries_),
+          terminal_probability(builder.terminal_probability_),
+          epsilon_probability(builder.epsilon_probability_),
+          ref_probability(builder.ref_probability_),
+          seed_it(builder.seed_it_),
+          memory_cells_number(builder.memory_cells_number_),
+          alphabet(builder.alphabet_) {}
+
 	void write_to_file(const std::string& filename);
 
-	void set_terminal_probability(int elem);
+    int getInitial() const {
+        return initial;
+    }
+
+    int getStatesNumber() const {
+        return states_number;
+    }
+
+    int getMaxEdgesNumber() const {
+        return max_edges_number;
+    }
+
+    int getEdgesNumber() const {
+        return edges_number;
+    }
+
+    int getColors() const {
+        return colors;
+    }
+
+    int getColorsTries() const {
+        return colors_tries;
+    }
+
+    int getTerminalProbability() const {
+        return terminal_probability;
+    }
+
+    int getEpsilonProbability() const {
+        return epsilon_probability;
+    }
+
+    int getRefProbability() const {
+        return ref_probability;
+    }
+
+    int getSeedIt() const {
+        return seed_it;
+    }
+
+    int getMemoryCellsNumber() const {
+        return memory_cells_number;
+    }
 
-	void set_states_number(int n);
+    const std::vector<char>& getAlphabet() const {
+        return alphabet;
+    }
 };