From 314e97ac5307f5053fc0c31ec23c39ba9c9a0aac Mon Sep 17 00:00:00 2001
From: Benjamin Paassen <bpaassen@techfak.uni-bielefeld.de>
Date: Wed, 3 Dec 2014 00:57:49 +0100
Subject: fixed some subtle design errors in SelectorNodes and implemented
 SelectorNode::getChildren.

---
 src/core/CSS.cpp | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
 src/core/CSS.hpp | 49 +++++++++++++++++++++++++++++++++++--------------
 2 files changed, 84 insertions(+), 14 deletions(-)
 create mode 100644 src/core/CSS.cpp

(limited to 'src/core')

diff --git a/src/core/CSS.cpp b/src/core/CSS.cpp
new file mode 100644
index 0000000..06d062e
--- /dev/null
+++ b/src/core/CSS.cpp
@@ -0,0 +1,49 @@
+/*
+    Ousía
+    Copyright (C) 2014  Benjamin Paaßen, Andreas Stöckel
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "CSS.hpp"
+
+namespace ousia {
+
+/**
+ * This returns all children of this SelectorNode that are connected by
+ * the given operator, have the given className and the given
+ * PseudoSelector.
+ */
+std::vector<Rooted<SelectorNode>> SelectorNode::getChildren(
+    const SelectionOperator &op, const std::string &className,
+    const PseudoSelector &select)
+{
+	std::vector<Rooted<SelectorNode>> out;
+	for(auto& e : edges){
+		if(e->getSelectionOperator() != op){
+			continue;
+		}
+		if(e->getTarget()->getName() != className){
+			continue;
+		}
+		if(e->getTarget()->getPseudoSelector() != select){
+			continue;
+		}
+		out.push_back(e->getTarget());
+	}
+	return out;
+}
+
+
+}
diff --git a/src/core/CSS.hpp b/src/core/CSS.hpp
index 4f7cd3b..f5d8c1d 100644
--- a/src/core/CSS.hpp
+++ b/src/core/CSS.hpp
@@ -19,12 +19,9 @@
 #ifndef _OUSIA_CSS_HPP_
 #define _OUSIA_CSS_HPP_
 
-#include <istream>
 #include <map>
 #include <vector>
-#include <tuple>
 
-#include "BufferedCharReader.hpp"
 #include "Managed.hpp"
 #include "Node.hpp"
 
@@ -48,17 +45,18 @@ struct Specificity {
 	Specificity(int b, int c, int d) : b(b), c(c), d(d) {}
 };
 
-bool operator<(const Specificity &x, const Specificity &y)
+//TODO: Is this correct? I used this to prevent "multiple definition" errors
+inline bool operator<(const Specificity &x, const Specificity &y)
 {
 	return std::tie(x.b, x.c, x.d) < std::tie(y.b, y.c, y.d);
 }
 
-bool operator>(const Specificity &x, const Specificity &y)
+inline bool operator>(const Specificity &x, const Specificity &y)
 {
 	return std::tie(x.b, x.c, x.d) > std::tie(y.b, y.c, y.d);
 }
 
-bool operator==(const Specificity &x, const Specificity &y)
+inline bool operator==(const Specificity &x, const Specificity &y)
 {
 	return std::tie(x.b, x.c, x.d) == std::tie(y.b, y.c, y.d);
 }
@@ -135,6 +133,11 @@ public:
 	{
 	}
 
+	PseudoSelector(std::string name, bool generative)
+	    : name(std::move(name)), args(), generative(generative)
+	{
+	}
+
 	const std::string &getName() const { return name; }
 
 	const std::vector<std::string> &getArgs() const { return args; }
@@ -142,6 +145,18 @@ public:
 	const bool &isGenerative() const { return generative; }
 };
 
+inline bool operator==(const PseudoSelector &x, const PseudoSelector &y)
+{
+	return std::tie(x.getName(), x.getArgs(), x.isGenerative()) ==
+	       std::tie(y.getName(), y.getArgs(), y.isGenerative());
+}
+
+inline bool operator!=(const PseudoSelector &x, const PseudoSelector &y)
+{
+	return std::tie(x.getName(), x.getArgs(), x.isGenerative()) !=
+	       std::tie(y.getName(), y.getArgs(), y.isGenerative());
+}
+
 /**
  * A SelectionOperator for now is just an enumeration class deciding
  * whether a SelectorEdge builds a Descendant relationship or a
@@ -227,7 +242,7 @@ public:
 		}
 	};
 
-//Content of the SelectorNode class.
+	// Content of the SelectorNode class.
 private:
 	const PseudoSelector pseudoSelector;
 	ManagedVector<SelectorEdge> edges;
@@ -235,24 +250,30 @@ private:
 	//	Owned<RuleSet> ruleSets;
 
 public:
-	SelectorNode(Manager &mgr, std::string name, PseudoSelector pseudoSelector,
-	             const std::vector<Handle<SelectorEdge>> &edges//,
-	             // const std::vector<Handle<RuleSet>> &ruleSets
-	             )
+	SelectorNode(Manager &mgr, std::string name, PseudoSelector pseudoSelector)
 	    : Node(mgr, std::move(name)),
 	      pseudoSelector(std::move(pseudoSelector)),
-	      edges(this,edges)//,
+	      edges(this)  //,
 	// ruleSets(acquire(ruleSets))
 	{
 	}
 
 	const PseudoSelector &getPseudoSelector() const { return pseudoSelector; }
 
-	const ManagedVector<SelectorEdge> &getEdges() const { return edges; }
+	ManagedVector<SelectorEdge> &getEdges() { return edges; }
 
 	//	const std::vector<Owned<RuleSet>> &getRuleSets() const { return
 	// ruleSets; }
-};
 
+	/**
+	 * This returns all children of this SelectorNode that are connected by
+	 * the given operator, have the given className and the given
+	 * PseudoSelector.
+	 */
+	std::vector<Rooted<SelectorNode>> getChildren(const SelectionOperator &op,
+	                                              const std::string &className,
+	                                              const PseudoSelector &select);
+
+};
 }
 #endif
-- 
cgit v1.2.3