initial test of NodeSet extend

include/bbp/sonata/node_sets.h

@@ -48,6 +48,15 @@ class SONATA_API NodeSets
  */
  std::set<std::string> names() const;
 
+ /**
+ * Extend this NodeSets to include the `other` nodeset
+ *
+ * Duplicate names are overriden with the values from `other`
+ *
+ * The duplicate names are returned.
+ */
+ std::set<std::string> extend(const NodeSets& other) const;
+
  /**
  * Return string version of node sets
  */

python/bindings.cpp

@@ -515,6 +515,9 @@ PYBIND11_MODULE(_libsonata, m) {
  .def_static("from_file", [](py::object path) { return NodeSets::fromFile(py::str(path)); })
  .def_property_readonly("names", &NodeSets::names, DOC_NODESETS(names))
  .def("materialize", &NodeSets::materialize, DOC_NODESETS(materialize))
+ .def("extend", &NodeSets::extend,
+ "other"_a,
+ DOC_NODESETS(extend))
  .def("toJSON", &NodeSets::toJSON, DOC_NODESETS(toJSON));
 
  py::class_<CommonPopulationProperties>(m,

python/generated/docstrings.h

@@ -263,6 +263,13 @@ static const char *__doc_bbp_sonata_NodeSets_NodeSets_3 = R"doc()doc";
 
 static const char *__doc_bbp_sonata_NodeSets_NodeSets_4 = R"doc()doc";
 
+static const char *__doc_bbp_sonata_NodeSets_extend =
+R"doc(Extend this NodeSets to include the `other` nodeset
+
+Duplicate names are overriden with the values from `other`
+
+The duplicate names are returned.)doc";
+
 static const char *__doc_bbp_sonata_NodeSets_fromFile = R"doc(Open a SONATA `node sets` file from a path */)doc";
 
 static const char *__doc_bbp_sonata_NodeSets_impl = R"doc()doc";

python/tests/test_nodesets.py

@@ -181,3 +181,20 @@ def test_library_datatype(self):
 
  j = json.dumps({"NodeSet0": { "E-mapping-good": [0, 1, ] }})
  self.assertRaises(SonataError, NodeSets(j).materialize, "NodeSet0", self.population)
+
+ def test_extend(self):
+ ns0 = NodeSets(json.dumps({"NodeSet0": { "E-mapping-good": 0 }}))
+ dup = ns0.extend(ns0)
+ self.assertEqual(dup, {"NodeSet0"})
+ self.assertEqual(ns0.names, {"NodeSet0"})
+
+ ns1 = NodeSets(json.dumps({"NodeSet1": { "E-mapping-good": 0 }}))
+ dup = ns0.extend(ns1)
+ self.assertEqual(dup, set())
+ self.assertEqual(ns0.names, {"NodeSet0", "NodeSet1"})
+
+ ns0 = NodeSets(json.dumps({"NodeSet0": { "E-mapping-good": 0 }}))
+ ns1 = NodeSets(json.dumps({"NodeSet0": { "E-mapping-good": 0 }}))
+ dup = ns0.extend(ns1)
+ self.assertEqual(dup, {"NodeSet0"})
+ self.assertEqual(ns0.names, {"NodeSet0"})

src/node_sets.cpp

@@ -55,6 +55,7 @@ class NodeSetRule
  virtual bool is_compound() const {
  return false;
  }
+ virtual std::unique_ptr<NodeSetRule> clone() const = 0;
 };
 
 using NodeSetRulePtr = std::unique_ptr<NodeSetRule>;
@@ -101,6 +102,20 @@ class NodeSets
  return getMapKeys(node_sets_);
  }
 
+ std::set<std::string> extend(const NodeSets& other){
+ if(&other == this){
+ return names();
+ }
+ std::set<std::string> duplicates;
+ for(const auto& ns : other.node_sets_){
+ if(node_sets_.count(ns.first) > 0){
+ duplicates.insert(ns.first);
+ }
+ node_sets_[ns.first] = ns.second->clone();
+ }
+ return duplicates;
+ }
+
  std::string toJSON() const {
  std::string ret{"{\n"};
  for (const auto& pair : node_sets_) {
@@ -125,15 +140,20 @@ class NodeSetNullRule: public NodeSetRule
  std::string toJSON() const final {
  return {};
  }
+
+ std::unique_ptr<NodeSetRule> clone() const final
+ {
+ return std::make_unique<detail::NodeSetNullRule>();
+ }
 };
 
 // { 'region': ['region1', 'region2', ...] }
 template <typename T>
 class NodeSetBasicRule: public NodeSetRule
 {
  public:
- NodeSetBasicRule(std::string attribute, std::vector<T>& values)
- : attribute_(std::move(attribute))
+ NodeSetBasicRule(const std::string attribute, const std::vector<T>& values)
+ : attribute_(attribute)
  , values_(values) {}
 
  Selection materialize(const detail::NodeSets& /* unused */,
@@ -152,6 +172,11 @@ class NodeSetBasicRule: public NodeSetRule
  return toString(attribute_, values_);
  }
 
+ std::unique_ptr<NodeSetRule> clone() const final
+ {
+ return std::make_unique<detail::NodeSetBasicRule<T>>(attribute_, values_);
+ }
+
  private:
  std::string attribute_;
  std::vector<T> values_;
@@ -161,7 +186,7 @@ class NodeSetBasicRule: public NodeSetRule
 class NodeSetBasicPopulation: public NodeSetRule
 {
  public:
- explicit NodeSetBasicPopulation(std::vector<std::string>& values)
+ explicit NodeSetBasicPopulation(const std::vector<std::string>& values)
  : values_(values) {}
 
  Selection materialize(const detail::NodeSets& /* unused */,
@@ -177,6 +202,11 @@ class NodeSetBasicPopulation: public NodeSetRule
  return toString("population", values_);
  }
 
+ std::unique_ptr<NodeSetRule> clone() const final
+ {
+ return std::make_unique<detail::NodeSetBasicPopulation>(values_);
+ }
+
  private:
  std::vector<std::string> values_;
 };
@@ -185,7 +215,7 @@ class NodeSetBasicPopulation: public NodeSetRule
 class NodeSetBasicNodeIds: public NodeSetRule
 {
  public:
- explicit NodeSetBasicNodeIds(Selection::Values&& values)
+ explicit NodeSetBasicNodeIds(const Selection::Values& values)
  : values_(values) {}
 
  Selection materialize(const detail::NodeSets& /* unused */,
@@ -197,6 +227,11 @@ class NodeSetBasicNodeIds: public NodeSetRule
  return toString("node_ids", values_);
  }
 
+ std::unique_ptr<NodeSetRule> clone() const final
+ {
+ return std::make_unique<detail::NodeSetBasicNodeIds>(values_);
+ }
+
  private:
  Selection::Values values_;
 };
@@ -230,6 +265,16 @@ class NodeSetBasicMultiClause: public NodeSetRule
  return ret;
  }
 
+ std::unique_ptr<NodeSetRule> clone() const final
+ {
+ std::vector<NodeSetRulePtr> clauses;
+ clauses.reserve(clauses_.size());
+ for(const auto& clause : clauses_){
+ clauses.push_back(clause->clone());
+ }
+ return std::make_unique<detail::NodeSetBasicMultiClause>(std::move(clauses));
+ }
+
  private:
  std::vector<NodeSetRulePtr> clauses_;
 };
@@ -238,12 +283,12 @@ class NodeSetBasicMultiClause: public NodeSetRule
 class NodeSetBasicOperatorString: public NodeSetRule
 {
  public:
- explicit NodeSetBasicOperatorString(std::string attribute,
+ explicit NodeSetBasicOperatorString(const std::string& attribute,
  const std::string& op,
- std::string value)
+ const std::string& value)
  : op_(string2op(op))
- , attribute_(std::move(attribute))
- , value_(std::move(value)) {}
+ , attribute_(attribute)
+ , value_(value) {}
 
  Selection materialize(const detail::NodeSets& /* unused */,
  const NodePopulation& np) const final {
@@ -279,6 +324,11 @@ class NodeSetBasicOperatorString: public NodeSetRule
  }
  }
 
+ std::unique_ptr<NodeSetRule> clone() const final
+ {
+ return std::make_unique<detail::NodeSetBasicOperatorString>(attribute_, op2string(op_), value_);
+ }
+
  private:
  Op op_;
  std::string attribute_;
@@ -349,6 +399,11 @@ class NodeSetBasicOperatorNumeric: public NodeSetRule
  }
  }
 
+ std::unique_ptr<NodeSetRule> clone() const final
+ {
+ return std::make_unique<detail::NodeSetBasicOperatorNumeric>(name_, op2string(op_), value_);
+ }
+
  private:
  std::string name_;
  double value_;
@@ -382,6 +437,11 @@ class NodeSetCompoundRule: public NodeSetRule
  return targets_;
  }
 
+ std::unique_ptr<NodeSetRule> clone() const final
+ {
+ return std::make_unique<detail::NodeSetCompoundRule>(name_, targets_);
+ }
+
  private:
  std::string name_;
  CompoundTargets targets_;
@@ -673,6 +733,10 @@ std::set<std::string> NodeSets::names() const {
  return impl_->names();
 }
 
+std::set<std::string> NodeSets::extend(const NodeSets& other) const {
+ return impl_->extend(*other.impl_);
+}
+
 std::string NodeSets::toJSON() const {
  return impl_->toJSON();
 }