Another refactoring session:

o mk_cache_id() obsoleted by removing the node index from the dump
o node index output removed from each node and make optional in NodeDumper
o The visitors are no longer global, but associated with a tree
o Added Tree class to manage node trees and the (now implicit) dump cache
o Moved PolySet cache into PolySetRenderer

8 files changed, 108 insertions, 96 deletions

diff --git a/test-code/CSGTextRenderer.cc b/test-code/CSGTextRenderer.cc
index d9e3667..ab498f6 100644
--- a/test-code/CSGTextRenderer.cc
+++ b/test-code/CSGTextRenderer.cc
@@ -1,10 +1,10 @@
 #include "CSGTextRenderer.h"
+
 #include <string>
 #include <map>
 #include <list>
 #include "visitor.h"
 #include "state.h"
-#include "nodecache.h"
 #include "module.h" // FIXME: Temporarily for ModuleInstantiation
 
 #include "csgnode.h"
@@ -15,23 +15,9 @@
 #include <assert.h>
 #include <QRegExp>
 
-string CSGTextRenderer::getCSGString() const
-{
-	assert(this->root); 
-	// FIXME: assert that cache contains root
-	return this->cache[mk_cache_id(*this->root)];
-}
-
-// CGAL_Nef_polyhedron CSGTextRenderer::getCGALMesh() const
-// {
-// 	assert(this->root); 
-// // FIXME: assert that cache contains root
-// 	return this->cache[*this->root];
-// }
-
 bool CSGTextRenderer::isCached(const AbstractNode &node)
 {
-	return this->cache.contains(mk_cache_id(node));
+	return this->cache.contains(this->tree.getString(node));
 }
 
 /*!
@@ -118,7 +104,7 @@ void CSGTextRenderer::applyToChildren(const AbstractNode &node, CSGTextRenderer:
 				 iter != this->visitedchildren[node.index()].end();
 				 iter++) {
 			const AbstractNode *chnode = iter->first;
-			const QString &chcacheid = iter->second;
+			const string &chcacheid = iter->second;
 			// FIXME: Don't use deep access to modinst members
 			if (chnode->modinst->tag_background) continue;
 			if (first) {
@@ -132,8 +118,7 @@ void CSGTextRenderer::applyToChildren(const AbstractNode &node, CSGTextRenderer:
 		}
 		N += ")";
 	}
-	QString cacheid = mk_cache_id(node);
-	this->cache.insert(cacheid, N);
+	this->cache.insert(this->tree.getString(node), N);
 }
 
 /*
@@ -235,8 +220,7 @@ Response CSGTextRenderer::visit(const State &state, const AbstractPolyNode &node
 // 	}
 
 			string N = typeid(node).name();
-			QString cacheid = mk_cache_id(node);
-			this->cache.insert(cacheid, N);
+			this->cache.insert(this->tree.getString(node), N);
 		
 // 		std::cout << "Insert: " << N << "\n";
 // 		std::cout << "Node: " << cacheid.toStdString() << "\n\n";
@@ -254,33 +238,28 @@ Response CSGTextRenderer::visit(const State &state, const AbstractPolyNode &node
 void CSGTextRenderer::addToParent(const State &state, const AbstractNode &node)
 {
 	assert(state.isPostfix());
-	QString cacheid = mk_cache_id(node);
 	this->visitedchildren.erase(node.index());
-	if (!state.parent()) {
-		this->root = &node;
-	}
-	else {
-		this->visitedchildren[state.parent()->index()].push_back(std::make_pair(&node, cacheid));
+	if (state.parent()) {
+		this->visitedchildren[state.parent()->index()].push_back(std::make_pair(&node, this->tree.getString(node)));
 	}
 }
 
-/*!
-  Create a cache id of the entire tree under this node. This cache id
-	is a non-whitespace plaintext of the evaluated scad tree and is used
-	for lookup in cgal_nef_cache.
-*/
-QString CSGTextRenderer::mk_cache_id(const AbstractNode &node) const
+
+
+static uint hash(const uchar *p, int n)
 {
-	// FIXME: should we keep a cache of cache_id's to avoid recalculating this?
-	// -> check how often we recalculate it.
+    uint h = 0;
+    uint g;
+
+    while (n--) {
+        h = (h << 4) + *p++;
+        if ((g = (h & 0xf0000000)) != 0)
+            h ^= g >> 23;
+        h &= ~g;
+    }
+    return h;
+}
 
-	// FIXME: Get dump from dump cache
-	// FIXME: assert that cache contains node
-	QString cache_id = QString::fromStdString(this->dumpcache[node]);
-	// Remove all node indices and whitespace
-	cache_id.remove(QRegExp("[a-zA-Z_][a-zA-Z_0-9]*:"));
-	cache_id.remove(' ');
-	cache_id.remove('\t');
-	cache_id.remove('\n');
-	return cache_id;
+uint qHash(const string &str) {
+	return hash(reinterpret_cast<const uchar *>(str.c_str()), str.length());
 }
diff --git a/test-code/CSGTextRenderer.h b/test-code/CSGTextRenderer.h
index 22d722f..236f900 100644
--- a/test-code/CSGTextRenderer.h
+++ b/test-code/CSGTextRenderer.h
@@ -1,11 +1,15 @@
 #ifndef CSGTEXTRENDERER_H_
 #define CSGTEXTRENDERER_H_
 
+#include <qglobal.h>
 #include <string>
+extern uint qHash(const std::string &);
+
 #include <map>
 #include <list>
+#include <QHash>
 #include "visitor.h"
-#include "nodecache.h"
+#include "Tree.h"
 
 using std::string;
 using std::map;
@@ -15,8 +19,8 @@ using std::pair;
 class CSGTextRenderer : public Visitor
 {
 public:
-	enum CsgOp {UNION, INTERSECTION, DIFFERENCE, MINKOWSKI};
-	CSGTextRenderer(const NodeCache<string> &dumpcache) : root(NULL), dumpcache(dumpcache) {}
+	CSGTextRenderer(QHash<string, string> &cache, const Tree &tree) : 
+		cache(cache), tree(tree) {}
   virtual ~CSGTextRenderer() {}
 
   virtual Response visit(const State &state, const AbstractNode &node);
@@ -25,21 +29,19 @@ public:
 	virtual Response visit(const State &state, const TransformNode &node);
 	virtual Response visit(const State &state, const AbstractPolyNode &node);
 
-	string getCSGString() const;
 private:
+	enum CsgOp {UNION, INTERSECTION, DIFFERENCE, MINKOWSKI};
   void addToParent(const State &state, const AbstractNode &node);
   bool isCached(const AbstractNode &node);
-	QString mk_cache_id(const AbstractNode &node) const;
 	void process(string &target, const string &src, CSGTextRenderer::CsgOp op);
 	void applyToChildren(const AbstractNode &node, CSGTextRenderer::CsgOp op);
 
   string currindent;
-  const AbstractNode *root;
-  typedef list<pair<const AbstractNode *, QString> > ChildList;
+  typedef list<pair<const AbstractNode *, string> > ChildList;
   map<int, ChildList> visitedchildren;
 
-	QHash<QString, string> cache;
-	const NodeCache<string> &dumpcache;
+	QHash<string, string> &cache;
+	const Tree &tree;
 };
 
 #endif
diff --git a/test-code/cgaltest.cc b/test-code/cgaltest.cc
index 8529da8..147e390 100644
--- a/test-code/cgaltest.cc
+++ b/test-code/cgaltest.cc
@@ -33,6 +33,7 @@
 #include "nodedumper.h"
 #include "CGALRenderer.h"
 #include "PolySetCGALRenderer.h"
+#include "Tree.h"
 
 #include <QApplication>
 #include <QFile>
@@ -61,6 +62,24 @@ void handle_dep(QString filename)
 	}
 }
 
+// FIXME: enforce some maximum cache size (old version had 100K vertices as limit)
+QHash<string, CGAL_Nef_polyhedron> cache;
+
+void cgalTree(Tree &tree)
+{
+	const AbstractNode *root = tree.root();
+	assert(root);
+	NodeCache<string> &cache = tree.cache();
+	NodeDumper dumper(cache, false);
+	Traverser trav(dumper, *root, Traverser::PRE_AND_POSTFIX);
+	trav.execute();
+	assert(!cache[*root].empty());
+
+	CSGTextRenderer renderer(csgcache, cache);
+	Traverser render(renderer, *root, Traverser::PRE_AND_POSTFIX);
+	render.execute();
+}
+
 int main(int argc, char **argv)
 {
 	if (argc != 2) {
@@ -146,11 +165,12 @@ int main(int argc, char **argv)
 	AbstractNode::resetIndexCounter();
 	root_node = root_module->evaluate(&root_ctx, &root_inst);
 
-	NodeDumper dumper;
-	Traverser trav(dumper, *root_node, Traverser::PRE_AND_POSTFIX);
-	trav.execute();
- 	std::string dumpstdstr = dumper.getDump() + "\n";
- 	std::cout << dumpstdstr << "\n";
+	Tree tree;
+	tree.setRoot(root_node);
+
+	cgalTree(tree);
+
+ 	std::cout << cache[tree.cache()[*root_node]] << "\n";
 
 	CGALRenderer cgalrenderer(dumper.getCache());
 	PolySetCGALRenderer psrenderer(cgalrenderer);
diff --git a/test-code/cgaltest.pro b/test-code/cgaltest.pro
index c181046..a91cb5b 100644
--- a/test-code/cgaltest.pro
+++ b/test-code/cgaltest.pro
@@ -1,10 +1,10 @@
 DEFINES += OPENSCAD_VERSION=test
 TEMPLATE = app
 
-OBJECTS_DIR = objects
-MOC_DIR = objects
-UI_DIR = objects
-RCC_DIR = objects
+OBJECTS_DIR = cgal-objects
+MOC_DIR = cgal-objects
+UI_DIR = cgal-objects
+RCC_DIR = cgal-objects
 INCLUDEPATH += ../src
 
 macx {
@@ -61,7 +61,8 @@ HEADERS += ../src/builtin.h \
            ../src/importnode.h \
            ../src/state.h \
            ../src/PolySetRenderer.h \
-           ../src/PolySetCGALRenderer.h
+           ../src/PolySetCGALRenderer.h \
+           ../src/Tree.h
 
 SOURCES += cgaltest.cc \
            ../src/export.cc \
@@ -98,4 +99,5 @@ SOURCES += cgaltest.cc \
            ../src/CGALRenderer.cc \
            ../src/traverser.cc \
            ../src/PolySetRenderer.cc \
-           ../src/PolySetCGALRenderer.cc
+           ../src/PolySetCGALRenderer.cc \
+           ../src/Tree.cc
diff --git a/test-code/csgtexttest.cc b/test-code/csgtexttest.cc
index b07bc92..f464900 100644
--- a/test-code/csgtexttest.cc
+++ b/test-code/csgtexttest.cc
@@ -23,6 +23,7 @@
  *
  */
 
+#include "CSGTextRenderer.h"
 #include "openscad.h"
 #include "node.h"
 #include "module.h"
@@ -30,14 +31,14 @@
 #include "value.h"
 #include "export.h"
 #include "builtin.h"
-#include "nodedumper.h"
-#include "CSGTextRenderer.h"
+#include "Tree.h"
 
 #include <QApplication>
 #include <QFile>
 #include <QDir>
 #include <QSet>
 #include <getopt.h>
+#include <assert.h>
 #include <iostream>
 
 QString commandline_commands;
@@ -60,6 +61,17 @@ void handle_dep(QString filename)
 	}
 }
 
+
+QHash<string, string> csgcache;
+void csgTree(Tree &tree)
+{
+	assert(tree.root());
+
+	CSGTextRenderer renderer(csgcache, tree);
+	Traverser render(renderer, *tree.root(), Traverser::PRE_AND_POSTFIX);
+	render.execute();
+}
+
 int main(int argc, char **argv)
 {
 	if (argc != 2) {
@@ -145,17 +157,13 @@ int main(int argc, char **argv)
 	AbstractNode::resetIndexCounter();
 	root_node = root_module->evaluate(&root_ctx, &root_inst);
 
+	Tree tree;
+	tree.setRoot(root_node);
 
-	NodeDumper dumper;
-	Traverser trav(dumper, *root_node, Traverser::PRE_AND_POSTFIX);
-	trav.execute();
- 	std::string dumpstdstr = dumper.getDump() + "\n";
- 	std::cout << dumpstdstr << "\n";
+	csgTree(tree);
+ 	std::cout << tree.getString(*root_node) << "\n";
 
-	CSGTextRenderer renderer(dumper.getCache());
-	Traverser render(renderer, *root_node, Traverser::PRE_AND_POSTFIX);
-	render.execute();
-	std::cout << renderer.getCSGString() << "\n";
+	std::cout << csgcache[tree.getString(*root_node)] << "\n";
 
 	destroy_builtin_functions();
 	destroy_builtin_modules();
diff --git a/test-code/csgtexttest.pro b/test-code/csgtexttest.pro
index 60dd731..a1c3148 100644
--- a/test-code/csgtexttest.pro
+++ b/test-code/csgtexttest.pro
@@ -61,11 +61,12 @@ HEADERS += ../src/builtin.h \
            ../src/csgnode.h \
            ../src/visitor.h \
            ../src/nodedumper.h \
-           ../src/CSGTextRenderer.h \
            ../src/nodecache.h \
            ../src/importnode.h \
            ../src/state.h \
-           ../src/PolySetRenderer.h
+           ../src/PolySetRenderer.h \
+           ../src/Tree.h \
+           CSGTextRenderer.h
 
 SOURCES += csgtexttest.cc \
            ../src/export.cc \
@@ -96,6 +97,7 @@ SOURCES += csgtexttest.cc \
            ../src/printutils.cc \
            ../src/progress.cc \
            ../src/nodedumper.cc \
-           ../src/CSGTextRenderer.cc \
            ../src/traverser.cc \
-           ../src/PolySetRenderer.cc
+           ../src/PolySetRenderer.cc \
+           ../src/Tree.cc \
+           CSGTextRenderer.cc
diff --git a/test-code/dumptest.cc b/test-code/dumptest.cc
index 36261b6..e26259c 100644
--- a/test-code/dumptest.cc
+++ b/test-code/dumptest.cc
@@ -31,12 +31,17 @@
 #include "export.h"
 #include "builtin.h"
 #include "nodedumper.h"
+#include "Tree.h"
 
 #include <QApplication>
 #include <QFile>
 #include <QDir>
 #include <QSet>
 #include <getopt.h>
+#include <assert.h>
+#include <iostream>
+
+using std::string;
 
 QString commandline_commands;
 const char *make_command = NULL;
@@ -144,23 +149,15 @@ int main(int argc, char **argv)
 	root_node = root_module->evaluate(&root_ctx, &root_inst);
 
 	// Cache test
-	QString dumpstr = root_node->dump();
-	QString dumpstr_cached = root_node->dump();
-	if (dumpstr != dumpstr_cached) rc = 1;
-
-	NodeDumper dumper;
-	Traverser trav(dumper, *root_node, Traverser::PRE_AND_POSTFIX);
-	trav.execute();
-	std::string dumpstdstr = dumper.getDump() + "\n";
-	trav.execute();
-	std::string dumpstdstr_cached = dumper.getDump() + "\n";
+	QString teststr("test");
+	Tree tree;
+	tree.setRoot(root_node);
+
+	string dumpstdstr = tree.getString(*root_node);
+	string dumpstdstr_cached = tree.getString(*root_node);
 	if (dumpstdstr != dumpstdstr_cached) rc = 1;
 
-	if (QString::fromStdString(dumpstdstr) != dumpstr) {
-		printf(dumpstr.toUtf8());
-		printf(dumpstdstr.c_str());
-		rc = 1;
-	}
+	std::cout << dumpstdstr << "\n";
 
 	destroy_builtin_functions();
 	destroy_builtin_modules();
diff --git a/test-code/dumptest.pro b/test-code/dumptest.pro
index f861f9a..80d51be 100644
--- a/test-code/dumptest.pro
+++ b/test-code/dumptest.pro
@@ -67,7 +67,8 @@ HEADERS += ../src/builtin.h \
            ../src/nodecache.h \
            ../src/importnode.h \
            ../src/state.h \
-           ../src/PolySetRenderer.h
+           ../src/PolySetRenderer.h \
+           ../src/Tree.h
 
 SOURCES += dumptest.cc \
            ../src/export.cc \
@@ -99,4 +100,5 @@ SOURCES += dumptest.cc \
            ../src/progress.cc \
            ../src/nodedumper.cc \
            ../src/traverser.cc \
-           ../src/PolySetRenderer.cc
+           ../src/PolySetRenderer.cc \
+           ../src/Tree.cc