Diff of /src/include/compiler/LogicalFactory.h [000000] .. [d62a98] Maximize Restore

Switch to side-by-side view

```--- a
+++ b/src/include/compiler/LogicalFactory.h
@@ -0,0 +1,66 @@
+#ifndef LOGICAL_FACTORY_H_
+#define LOGICAL_FACTORY_H_
+
+#include <graph/Graph.h>
+#include <graph/Node.h>
+#include <sarray/SArray.h>
+#include <compiler/NodeFactory.h>
+
+#include <vector>
+#include <utility>
+#include <map>
+#include <cfloat>
+
+class Function;
+class LogicalNode;
+
+/**
+ * A "logical pair", consisting of a function and a vector of arguments,
+ * uniquely defines a logical node.
+ */
+typedef std::pair<Function const*,std::vector<Node*> > LogicalPair;
+/**
+ * "Less than" operator for LogicalPairs. Two LogicalPairs A and B are
+ * considered to be equivalent (i.e. lt(A,B) and lt(B,A) are both
+ * false) if they have the same function, the parameter vectors are
+ * the same length, and an element-wise call to equal returns true.
+ *
+ * For non-equivalent LogicalPairs, the ordering is unique, but
+ * arbitrary. The only use of this function is for the STL map class
+ * with LogicalPair as key.
+ */
+bool lt(LogicalPair const &arg1, LogicalPair const &arg2);
+/**
+ * Function object for the STL map class using LogicalPair as a key
+ */
+struct ltlogical
+{
+  bool operator()(LogicalPair const &arg1, LogicalPair const &arg2)
+  {
+    return lt(arg1, arg2);
+  }
+};
+
+/**
+ * @short Factory object for logical nodes
+ * The value of a logical node is determined uniquely by its function
+ * and its parameters.  The purpose of a LogicalFactory is to avoid
+ * unnecessary duplication of logical nodes by having a container
+ * class and factory object for them that will create and/or lookup
+ * logical nodes based on the function and the parameter vector
+ */
+class LogicalFactory : public NodeFactory
+{
+  std::map<LogicalPair, LogicalNode*, ltlogical> _logicalmap;
+
+public:
+  /**
+   * Get a logical node with a given function and given parameters.
+   * The results are cached, so if a request is repeated, the same
+   * node will be returned.
+   */
+  LogicalNode *getLogicalNode(Function const *func,
+			      std::vector<Node*> const &param);
+};
+
+#endif /* LOGICAL_FACTORY_H_ */
```