From 314e97ac5307f5053fc0c31ec23c39ba9c9a0aac Mon Sep 17 00:00:00 2001 From: Benjamin Paassen 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 +++++++++++++++++++++++++++++++++++-------------- test/core/CSSTest.cpp | 27 ++++++++++++++++++++------- 3 files changed, 104 insertions(+), 21 deletions(-) create mode 100644 src/core/CSS.cpp 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 . +*/ + +#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> SelectorNode::getChildren( + const SelectionOperator &op, const std::string &className, + const PseudoSelector &select) +{ + std::vector> 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 #include #include -#include -#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 &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 edges; @@ -235,24 +250,30 @@ private: // Owned ruleSets; public: - SelectorNode(Manager &mgr, std::string name, PseudoSelector pseudoSelector, - const std::vector> &edges//, - // const std::vector> &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 &getEdges() const { return edges; } + ManagedVector &getEdges() { return edges; } // const std::vector> &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> getChildren(const SelectionOperator &op, + const std::string &className, + const PseudoSelector &select); + +}; } #endif diff --git a/test/core/CSSTest.cpp b/test/core/CSSTest.cpp index 19f8587..2c695d9 100644 --- a/test/core/CSSTest.cpp +++ b/test/core/CSSTest.cpp @@ -23,13 +23,13 @@ namespace ousia { TEST(Specificity, testOperators) { - Specificity s1{0,0,1}; - Specificity s2{0,1,1}; - Specificity s3{1,1,1}; - Specificity s4{0,0,2}; - Specificity s5{1,0,2}; - - //This should be s1 < s4 < s2 < s5 < s3 + Specificity s1{0, 0, 1}; + Specificity s2{0, 1, 1}; + Specificity s3{1, 1, 1}; + Specificity s4{0, 0, 2}; + Specificity s5{1, 0, 2}; + + // This should be s1 < s4 < s2 < s5 < s3 ASSERT_TRUE(s1 == s1); ASSERT_FALSE(s1 < s1); @@ -111,4 +111,17 @@ TEST(Specificity, testOperators) ASSERT_FALSE(s5 < s5); ASSERT_FALSE(s5 > s5); } + +TEST(SelectorNode, testGetChildren) +{ + Manager mgr(1); + Rooted root{new SelectorNode{mgr, "root", {"true", false}}}; + Rooted child{new SelectorNode{mgr, "A", {"true", false}}}; + root->getEdges().push_back( + new SelectorNode::SelectorEdge{mgr, child, SelectionOperator::DESCENDANT}); + std::vector> actual = + root->getChildren(SelectionOperator::DESCENDANT, "A", {"true", false}); + ASSERT_EQ(1,actual.size()); + ASSERT_EQ(child, actual[0]); +} } -- cgit v1.2.3