From 5f3cb0bf02ed32976370cf6c7f656d000b4d7694 Mon Sep 17 00:00:00 2001
From: Carlo Zancanaro <carlo@pc-4w14-0.cs.usyd.edu.au>
Date: Fri, 15 Jun 2012 11:26:32 +1000
Subject: Re-write heaps of code to work better.

---
 impl/Expression.hpp | 143 ++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 100 insertions(+), 43 deletions(-)

(limited to 'impl/Expression.hpp')

diff --git a/impl/Expression.hpp b/impl/Expression.hpp
index d3dfcf3..72318e4 100644
--- a/impl/Expression.hpp
+++ b/impl/Expression.hpp
@@ -1,68 +1,125 @@
 #ifndef EXPRESSION_HPP
 #define EXPRESSION_HPP
 
-#include <iostream>
-#include "VariableAssignment.hpp"
+#include <string>
+#include <vector>
+#include <sstream>
+#include "IdMap.hpp"
 #include "Operator.hpp"
 
-template<typename T>
-struct Variable;
-template<typename T>
-struct MaxStrategy;
-
-int ExpressionCount;
+template<typename Domain>
+struct VariableAssignment;
 
-template<typename T>
+template<typename Domain>
 struct Expression {
-  Expression(Operator<T>* op, const std::vector< Expression<T>* >& args)
-    : _operator(op), _arguments(args) { }
-  virtual ~Expression() {
-    if (!dynamic_cast<Variable<T>*>(_operator)) {
-      delete _operator;
-    }
+  virtual ~Expression() { }
+
+  virtual Domain eval(const VariableAssignment<Domain>&) const = 0;
+
+  virtual void print(std::ostream&) const = 0;
+};
+
+template<typename Domain>
+struct Constant : public Expression<Domain> {
+  Constant(const Domain& value)
+    : _value(value) { }
+
+  virtual Domain eval(const VariableAssignment<Domain>&) const {
+    return _value;
   }
-  virtual T operator() (const VariableAssignment<T>& assignment) const {
-    return (*_operator)(_arguments, assignment);
+
+  void print(std::ostream& cout) const {
+    cout << _value;
   }
-  protected:
-  Operator<T>* _operator;
-  std::vector< Expression<T>* > _arguments;
+
+  private:
+  Domain _value;
 };
 
-template<typename T>
-struct MaxExpression : public Expression<T> {
-  MaxExpression(const std::vector< Expression<T>* >& args)
-    : Expression<T>(new Maximum<T>, args) { }
+template<typename Domain>
+struct Variable : public Expression<Domain> {
+  Variable(const unsigned int& id, const std::string& name)
+    : _id(id), _name(name) { }
+
   unsigned int id() const {
     return _id;
   }
-  unsigned int id(unsigned int id) {
-    return (_id = id);
+  std::string name() const {
+    return _name;
   }
-  Expression<T>* argument(unsigned int i) const {
-    if (i >= Expression<T>::_arguments.size()) {
-      throw "Error";
+
+  virtual Domain eval(const VariableAssignment<Domain>& rho) const {
+    return rho[*this];
+  }
+
+  void print(std::ostream& cout) const {
+    cout << name();
+  }
+
+  private:
+  const unsigned int _id;
+  const std::string _name;
+};
+
+template<typename Domain>
+struct OperatorExpression : public Expression<Domain> {
+  OperatorExpression(const Operator<Domain>& op, const std::vector<Expression<Domain>*>& arguments)
+    : _operator(op), _arguments(arguments) { }
+
+  virtual Domain eval(const VariableAssignment<Domain>& rho) const {
+    std::vector<Domain> argumentValues;
+    for (typename std::vector<Expression<Domain>*>::const_iterator it = _arguments.begin();
+         it != _arguments.end();
+         ++it) {
+      argumentValues.push_back((*it)->eval(rho));
     }
-    return Expression<T>::_arguments[i];
+    return _operator.eval(argumentValues);
+  }
+
+  const std::vector<Expression<Domain>*> arguments() const {
+    return _arguments;
   }
-  virtual T operator() (const VariableAssignment<T>& assignment) const {
-    throw "error";
+
+  const Operator<Domain>& op() const {
+    return _operator;
   }
-  std::pair<T, unsigned int> bestStrategy(const VariableAssignment<T>& rho, const MaxStrategy<T>& strat) const {
-    std::pair<T, unsigned int> best = std::pair<T, unsigned int>(-infinity<T>(), 0);
-    for (unsigned int i = 0, size = Expression<T>::_arguments.size(); i < size; ++i) {
-      T value = strat(*Expression<T>::_arguments[i], rho);
-      if (value > best.first)
-        best = std::pair<T, unsigned int>(value, i);
+
+  void print(std::ostream& cout) const {
+    cout << _operator << "(";
+    for (unsigned int i = 0, length = _arguments.size();
+         i < length;
+         ++i) {
+      if (i > 0)
+        cout << ", ";
+      cout << *_arguments[i];
     }
-    std::cerr << "Best strategy: (" << best.first << ", " << best.second << ")" << std::endl << std::endl;
-    return best;
+    cout << ")";
+  }
+
+  private:
+  const Operator<Domain>& _operator;
+  const std::vector<Expression<Domain>*> _arguments;
+};
+
+template<typename Domain>
+struct MaxExpression : public OperatorExpression<Domain> {
+  MaxExpression(const unsigned int& id, const Maximum<Domain>& op, const std::vector<Expression<Domain>*>& arguments)
+    : OperatorExpression<Domain>(op, arguments), _id(id) { }
+
+  unsigned int id() const {
+    return _id;
   }
+
   private:
-  unsigned int _id;
+  const unsigned int _id;
 };
 
-#include "Variable.hpp"
-#include "MaxStrategy.hpp"
+template<typename T>
+std::ostream& operator<<(std::ostream& cout, const Expression<T>& exp) {
+  exp.print(cout);
+  return cout;
+}
+
+#include "VariableAssignment.hpp"
 
 #endif
-- 
cgit v1.2.3