Add beginning of generation

include/fractal.hpp

@@ -21,6 +21,8 @@ constexpr size_t g_max_cgroup_tokens = 16;
 constexpr size_t g_max_wgroup_weights = 8;
 constexpr size_t g_max_match_groups = 8;
 constexpr size_t g_max_match_wgroups = 4;
+constexpr size_t g_max_leafs = 128;
+constexpr size_t g_max_wleafs = 128;
 
 using token_id_t = uint32_t;
 using group_id_t = uint32_t;
@@ -252,16 +254,38 @@ class generator_t {
 	etl::vector<group_output_t, g_max_groups> m_group_outputs;
 	etl::vector<token_match_t, g_max_tokens> m_token_matches;
 
+	bool m_has_ruleset = false;
 	group_id_t m_axiom;
-	bool m_empty;
+
+	etl::vector<leaf_t, g_max_leafs> m_leaf_buf1;
+	etl::vector<leaf_t, g_max_leafs> m_leaf_buf2;
+
+	etl::vector<weighted_leaf_t, g_max_leafs> m_wleaf_buf1;
+	etl::vector<weighted_leaf_t, g_max_leafs> m_wleaf_buf2;
+
+	// Need to use pointers betwen etl::ivector does not implement swap :(
+	etl::ivector<leaf_t>* m_leafs_prev = &m_leaf_buf1;
+	etl::ivector<leaf_t>* m_leafs_cur = &m_leaf_buf2;
+	
+	etl::ivector<weighted_leaf_t>* m_wleafs_prev = &m_wleaf_buf1;
+	etl::ivector<weighted_leaf_t>* m_wleafs_cur = &m_wleaf_buf2;
 
 	uint32_t m_gen_num = 0;
 
 	void parse_group_characteristic(group_id_t gid, group_output_t& output, const ruleset_t& ruleset);
 
+	void swap_buffers();
+	void clear_current_buffers();
+	void clear_previous_buffers();
+	void clear_all_buffers();
+
+	bool generate_axiom(etl::ivector<marker_t>& out_markers);
+	bool generate_leafs(etl::ivector<marker_t>& out_markers);
+	bool generate_wleafs(etl::ivector<marker_t>& out_markers);
+
 public:
-	generator_t() : m_empty(true), m_axiom(0) { }
+	generator_t() : m_axiom(0) { }
-	generator_t(const ruleset_t& ruleset) : m_empty(false), m_axiom(0) {
+	generator_t(const ruleset_t& ruleset) : m_axiom(0) {
 		parse_ruleset(ruleset);
 	}
 
@@ -282,8 +306,7 @@ public:
 	 * the current generation to @p out_markers. If there is not enough room
 	 * for all of the child markers, @p out_markers is unmodified. 
 	 */
-	template <typename CONTAINER_T>
+	bool step_generation(etl::ivector<marker_t>& out_markers);
-	bool step_generation(CONTAINER_T& out_markers);
 
 	uint32_t generation_num() const { return m_gen_num; }
 };

src/fractal.cpp

@@ -115,6 +115,8 @@ branch_rule_id_t ruleset_t::add_branch_rule_weighted(token_id_t match, weighted_
 void generator_t::parse_ruleset(const ruleset_t& ruleset) {
 	mlog::debug << "Parsing ruleset" << endl;
 
+	clear_all_buffers();
+	m_has_ruleset = true;
 	m_axiom = ruleset.get_axiom();
 
 	for (weighted_group_id_t wgid = 0; wgid < ruleset.num_weighted_groups(); ++wgid) {
@@ -135,9 +137,6 @@ void generator_t::parse_ruleset(const ruleset_t& ruleset) {
 
 		parse_group_characteristic(gid, m_group_outputs.back(), ruleset);
 	}
-
-	
-	m_empty = false;
 }
 
 void generator_t::parse_group_characteristic(group_id_t id, group_output_t& output, const ruleset_t& ruleset) {
@@ -206,5 +205,50 @@ void generator_t::parse_group_characteristic(group_id_t id, group_output_t& outp
 	}
 }
 
+void generator_t::swap_buffers() {
+	std::swap(m_leafs_cur, m_leafs_prev);
+	std::swap(m_wleafs_cur, m_wleafs_prev);
+}
+
+void generator_t::clear_current_buffers() {
+	m_leafs_cur->clear();
+	m_wleafs_cur->clear();
+}
+
+void generator_t::clear_previous_buffers() {
+	m_leafs_prev->clear();
+	m_wleafs_prev->clear();
+}
+
+void generator_t::clear_all_buffers() {
+	clear_current_buffers();
+	clear_previous_buffers();
+}
+
+bool generator_t::generate_axiom(etl::ivector<marker_t>& out_markers) {
+	return false;
+}
+bool generator_t::generate_leafs(etl::ivector<marker_t>& out_markers) {
+	return false;
+}
+bool generator_t::generate_wleafs(etl::ivector<marker_t>& out_markers) {
+	return false;
+}
+
+bool generator_t::step_generation(etl::ivector<marker_t>& out_markers) {
+	swap_buffers();
+	clear_current_buffers();
+
+	bool good = true;
+
+	if (m_leafs_prev->empty() && m_leafs_cur->empty()) {
+		good = generate_axiom(out_markers);
+	} else {
+		good = generate_leafs(out_markers) && generate_wleafs(out_markers);
+	}
+
+	return good;
+}
+
 } // namespace fractal