make nodes more const friendly and prepare their functions for stateless work

Since the nodes won't be holding any rendering data themselves in this system,
we may as well enforce some level of non-write access by setting all the
functions to const. They were already const-friendly, they just weren't
labelled as such.

app/node/value.cpp

@@ -0,0 +1,153 @@
+#include "value.h"
+
+NodeValueDatabase::NodeValueDatabase()
+{
+
+}
+
+NodeValueTable NodeValueDatabase::operator[](const QString &input_id) const
+{
+  return tables_.value(input_id);
+}
+
+NodeValueTable NodeValueDatabase::operator[](const NodeInput *input) const
+{
+  return tables_.value(input->id());
+}
+
+void NodeValueDatabase::Insert(const QString &key, const NodeValueTable &value)
+{
+  tables_.insert(key, value);
+}
+
+void NodeValueDatabase::Insert(const NodeInput *key, const NodeValueTable &value)
+{
+  tables_.insert(key->id(), value);
+}
+
+NodeValueTable NodeValueDatabase::Merge() const
+{
+  if (tables_.size() == 1) {
+    return tables_.begin().value();
+  }
+
+  int row = 0;
+
+  NodeValueTable merged_table;
+
+  QHash<QString, NodeValueTable>::const_iterator iterator;
+
+  // Slipstreams all tables together
+  // FIXME: I don't actually know if this is the right approach...
+  for (iterator = tables_.begin();iterator != tables_.end();iterator++) {
+    const NodeValueTable& table = iterator.value();
+
+    if (row >= table.Count()) {
+      continue;
+    }
+
+    int row_index = table.Count() - 1 - row;
+
+    merged_table.Prepend(table.At(row_index));
+  }
+
+  return merged_table;
+}
+
+NodeValue::NodeValue(const NodeParam::DataType &type, const QVariant &data, const QString &tag) :
+  type_(type),
+  data_(data),
+  tag_(tag)
+{
+}
+
+const NodeParam::DataType &NodeValue::type() const
+{
+  return type_;
+}
+
+const QString &NodeValue::tag() const
+{
+  return tag_;
+}
+
+const QVariant &NodeValue::data() const
+{
+  return data_;
+}
+
+NodeValueTable::NodeValueTable()
+{
+}
+
+QVariant NodeValueTable::Get(const NodeParam::DataType &type, const QString &tag)
+{
+  return GetInternal(type, tag, false);
+}
+
+QVariant NodeValueTable::Take(const NodeParam::DataType &type, const QString &tag)
+{
+  return GetInternal(type, tag, true);
+}
+
+void NodeValueTable::Push(const NodeValue &value)
+{
+  values_.append(value);
+}
+
+void NodeValueTable::Push(const NodeParam::DataType &type, const QVariant &data, const QString &tag)
+{
+  Push(NodeValue(type, data, tag));
+}
+
+void NodeValueTable::Prepend(const NodeValue &value)
+{
+  values_.prepend(value);
+}
+
+void NodeValueTable::Prepend(const NodeParam::DataType &type, const QVariant &data, const QString &tag)
+{
+  Prepend(NodeValue(type, data, tag));
+}
+
+const NodeValue &NodeValueTable::At(int index) const
+{
+  return values_.at(index);
+}
+
+int NodeValueTable::Count() const
+{
+  return values_.size();
+}
+
+bool NodeValueTable::isEmpty() const
+{
+  return values_.isEmpty();
+}
+
+QVariant NodeValueTable::GetInternal(const NodeParam::DataType &type, const QString &tag, bool remove)
+{
+  int index = -1;
+
+  for (int i=values_.size() - 1;i>=0;i--) {
+    const NodeValue& v = values_.at(i);
+
+    if (v.type() & type) {
+      index = i;
+
+      if (tag.isEmpty() || tag == v.tag()) {
+        break;
+      }
+    }
+  }
+
+  if (index >= 0) {
+    if (remove) {
+      values_.removeAt(index);
+    }
+
+    return values_.at(index).data();
+  }
+
+  return QVariant();
+}